Eventloop (DataKernel: Event Loop 2.5.13 API)

java.lang.Object
- io.datakernel.eventloop.Eventloop

All Implemented Interfaces:

EventloopExecutor, Scheduler, EventloopJmxMBean, EventloopJmxMBeanEx, CurrentTimeProvider, Initializable<Eventloop>, Runnable, Executor
```
public final class Eventloop
extends Object
implements Runnable, EventloopExecutor, Scheduler, CurrentTimeProvider, Initializable<Eventloop>, EventloopJmxMBeanEx
```
It is internal class for asynchronous programming. In asynchronous programming model, blocking operations (like I/O or long-running computations) in Eventloop thread must be avoided. Async versions of such operations should be used.
Eventloop represents infinite loop with only one blocking operation selector.select() which selects a set of keys whose corresponding channels are ready for I/O operations. With these keys and queues with tasks, which was added to Eventloop from the outside, it begins asynchronous executing from one thread it in method run() which is overridden because it is implementation of Runnable. Working of this eventloop will be ended, when it has not selected keys and its queues with tasks are empty.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class Eventloop.Scope

Nested Classes
Modifier and Type	Class and Description
`class`	`Eventloop.Scope`

Field Summary

Fields
Modifier and Type Field and Description

static AsyncTimeoutException CONNECT_TIMEOUT

static Duration DEFAULT_IDLE_INTERVAL
- Fields inherited from interface io.datakernel.time.CurrentTimeProvider
  THREAD_LOCAL_TIME_PROVIDER

Fields
Modifier and Type	Field and Description
`static AsyncTimeoutException`	`CONNECT_TIMEOUT`
`static Duration`	`DEFAULT_IDLE_INTERVAL`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`breakEventloop()`
`void`	`closeChannel(SelectableChannel channel)`
`void`	`closeChannel(SelectionKey channelKey)`
`void`	`completeExternalTask()` Notifies the event loop about completion of corrensponding operation in other threads.
`Stage<SocketChannel>`	`connect(SocketAddress address)` Connects to given socket address asynchronously.
`Stage<SocketChannel>`	`connect(SocketAddress address, int timeout)` Connects to given socket address asynchronously with a specified timeout value.
`static Eventloop`	`create()`
`static Eventloop`	`create(CurrentTimeProvider currentTimeProvider)`
`static DatagramChannel`	`createDatagramChannel(DatagramSocketSettings datagramSocketSettings, InetSocketAddress bindAddress, InetSocketAddress connectAddress)` Registers new UDP connection in this eventloop.
`long`	`currentTimeMillis()` Returns current time of this eventloop
`void`	`execute(Runnable runnable)` Posts a new task from other threads.
`static Eventloop`	`getCurrentEventloop()`
`Eventloop`	`getEventloop()`
`Thread`	`getEventloopThread()`
`FatalErrorHandler`	`getFatalErrorHandler()`
`Duration`	`getIdleInterval()`
`boolean`	`getKeepAlive()`
`int`	`getLoop()`
`EventloopStats`	`getStats()`
`int`	`getThreadPriority()`
`ThrottlingController`	`getThrottlingController()`
`long`	`getTick()`
`boolean`	`inEventloopThread()`
`boolean`	`isExtendedMonitoring()`
`void`	`keepAlive(boolean keepAlive)` Sets the flag keep alive, if it is true it means that working of this Eventloop will be continued even in case when all tasks have been executed and it doesn't have selected keys.
`ServerSocketChannel`	`listen(InetSocketAddress address, ServerSocketSettings serverSocketSettings, AcceptCallback acceptCallback)` Creates `ServerSocketChannel` that listens on InetSocketAddress.
`void`	`post(Runnable runnable)` Posts a new task to the beginning of localTasks.
`void`	`postLater(Runnable runnable)` Posts a new task to the end localTasks.
`void`	`recordFatalError(Throwable e, Object context)`
`long`	`refreshTimestampAndGet()`
`void`	`run()` Overridden method from Runnable that executes tasks while this eventloop is alive.
`ScheduledRunnable`	`schedule(long timestamp, Runnable runnable)` Schedules new task.
`ScheduledRunnable`	`scheduleBackground(long timestamp, Runnable runnable)` Schedules new background task.
`static void`	`setGlobalFatalErrorHandler(FatalErrorHandler handler)`
`void`	`setIdleInterval(Duration idleInterval)`
`void`	`startExtendedMonitoring()`
`void`	`startExternalTask()` Notifies the event loop about concurrent operation in other threads.
`void`	`stopExtendedMonitoring()`
`<T> CompletableFuture<T>`	`submit(AsyncCallable<T> asyncCallable)` Works the same as `submit(Runnable)` except for `AsyncCallable`
`<T> CompletableFuture<T>`	`submit(Callable<T> callable)` Works the same as `submit(Runnable)` except for `Callable`
`CompletableFuture<Void>`	`submit(Runnable runnable)` Submits `Runnable` to eventloop for execution
`long`	`tick()`
`String`	`toString()`
`Eventloop.Scope`	`useCurrentThread()`
`Eventloop`	`withCurrentThread()`
`Eventloop`	`withFatalErrorHandler(FatalErrorHandler fatalErrorHandler)`
`Eventloop`	`withIdleInterval(Duration idleInterval)`
`Eventloop`	`withSelectorProvider(SelectorProvider selectorProvider)`
`Eventloop`	`withThreadName(String threadName)`
`Eventloop`	`withThreadPriority(int threadPriority)`
`Eventloop`	`withThrottlingController(ThrottlingController throttlingController)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.datakernel.eventloop.Scheduler
delay, delay, delayBackground, delayBackground, schedule, scheduleBackground

Methods inherited from interface io.datakernel.time.CurrentTimeProvider
currentInstant, ofSystem, ofThreadLocal, ofTimeSequence

Methods inherited from interface io.datakernel.util.Initializable
initialize, initialize

Methods inherited from interface io.datakernel.jmx.EventloopJmxMBeanEx
getSmoothingWindow, resetStats, setSmoothingWindow

- Field Detail
  - CONNECT_TIMEOUT
```
public static final AsyncTimeoutException CONNECT_TIMEOUT
```
  - DEFAULT_IDLE_INTERVAL
```
public static final Duration DEFAULT_IDLE_INTERVAL
```
- Method Detail
  - create
```
public static Eventloop create()
```
  - create
```
public static Eventloop create(CurrentTimeProvider currentTimeProvider)
```
  - withThreadName
```
public Eventloop withThreadName(String threadName)
```
  - withThreadPriority
```
public Eventloop withThreadPriority(int threadPriority)
```
  - withThrottlingController
```
public Eventloop withThrottlingController(@Nullable
                                          ThrottlingController throttlingController)
```
  - withFatalErrorHandler
```
public Eventloop withFatalErrorHandler(FatalErrorHandler fatalErrorHandler)
```
  - withSelectorProvider
```
public Eventloop withSelectorProvider(SelectorProvider selectorProvider)
```
  - withIdleInterval
```
public Eventloop withIdleInterval(Duration idleInterval)
```
  - withCurrentThread
```
public Eventloop withCurrentThread()
```
  - useCurrentThread
```
public Eventloop.Scope useCurrentThread()
```
  - getCurrentEventloop
```
public static Eventloop getCurrentEventloop()
```
  - getThrottlingController
```
@Nullable
public ThrottlingController getThrottlingController()
```
  - closeChannel
```
public void closeChannel(SelectionKey channelKey)
```
  - closeChannel
```
public void closeChannel(SelectableChannel channel)
```
  - inEventloopThread
```
public boolean inEventloopThread()
```
  - keepAlive
```
public void keepAlive(boolean keepAlive)
```
    Sets the flag keep alive, if it is true it means that working of this Eventloop will be continued even in case when all tasks have been executed and it doesn't have selected keys.
    
    Parameters:
    
    keepAlive - flag for setting
  - breakEventloop
```
public void breakEventloop()
```
  - getEventloopThread
```
@Nullable
public Thread getEventloopThread()
```
  - run
```
public void run()
```
    Overridden method from Runnable that executes tasks while this eventloop is alive.
    
    Specified by:
    
    run in interface Runnable
  - listen
```
public ServerSocketChannel listen(InetSocketAddress address,
                                  ServerSocketSettings serverSocketSettings,
                                  AcceptCallback acceptCallback)
                           throws IOException
```
    Creates ServerSocketChannel that listens on InetSocketAddress.
    
    Parameters:
    
    address - InetSocketAddress that server will listen
    
    serverSocketSettings - settings from this server channel
    
    acceptCallback - callback that will be called when new incoming connection is being accepted. It can be called multiple times.
    
    Returns:
    
    server channel
    
    Throws:
    
    IOException - If some I/O error occurs
  - createDatagramChannel
```
public static DatagramChannel createDatagramChannel(DatagramSocketSettings datagramSocketSettings,
                                                    @Nullable
                                                    InetSocketAddress bindAddress,
                                                    @Nullable
                                                    InetSocketAddress connectAddress)
                                             throws IOException
```
    Registers new UDP connection in this eventloop.
    
    Parameters:
    
    bindAddress - address for binding DatagramSocket for this connection.
    
    Returns:
    
    DatagramSocket of this connection
    
    Throws:
    
    IOException - if an I/O error occurs on opening DatagramChannel
  - connect
```
public Stage<SocketChannel> connect(SocketAddress address)
```
    Connects to given socket address asynchronously.
    
    Parameters:
    
    address - socketChannel's address
  - connect
```
public Stage<SocketChannel> connect(SocketAddress address,
                                    int timeout)
```
    Connects to given socket address asynchronously with a specified timeout value. A timeout of zero is interpreted as an default system timeout
    
    Parameters:
    
    address - socketChannel's address
    
    timeout - the timeout value to be used in milliseconds, 0 as default system connection timeout
  - tick
```
public long tick()
```
  - post
```
public void post(Runnable runnable)
```
    Posts a new task to the beginning of localTasks. This method is recommended, since task will be executed as soon as possible without invalidating CPU cache.
    
    Parameters:
    
    runnable - runnable of this task
  - postLater
```
public void postLater(Runnable runnable)
```
    Posts a new task to the end localTasks.
    
    Parameters:
    
    runnable - runnable of this task
  - execute
```
public void execute(Runnable runnable)
```
    Posts a new task from other threads. This is the preferred method of communicating with eventloop from another threads.
    
    Specified by:
    
    execute in interface Executor
    
    Parameters:
    
    runnable - runnable of this task
  - schedule
```
public ScheduledRunnable schedule(long timestamp,
                                  Runnable runnable)
```
    Schedules new task. Returns ScheduledRunnable with this runnable.
    
    Specified by:
    
    schedule in interface Scheduler
    
    Parameters:
    
    timestamp - timestamp after which task will be ran
    
    runnable - runnable of this task
    
    Returns:
    
    scheduledRunnable, which could used for cancelling the task
  - scheduleBackground
```
public ScheduledRunnable scheduleBackground(long timestamp,
                                            Runnable runnable)
```
    Schedules new background task. Returns ScheduledRunnable with this runnable.
    If eventloop contains only background tasks, it will be closed
    
    Specified by:
    
    scheduleBackground in interface Scheduler
    
    Parameters:
    
    timestamp - timestamp after which task will be ran
    
    runnable - runnable of this task
    
    Returns:
    
    scheduledRunnable, which could used for cancelling the task
  - startExternalTask
```
public void startExternalTask()
```
    Notifies the event loop about concurrent operation in other threads. Eventloop will not exit until all external tasks are complete.
  - completeExternalTask
```
public void completeExternalTask()
```
    Notifies the event loop about completion of corrensponding operation in other threads. Failure to call this method will prevent the event loop from exiting.
  - refreshTimestampAndGet
```
public long refreshTimestampAndGet()
```
  - currentTimeMillis
```
public long currentTimeMillis()
```
    Returns current time of this eventloop
    
    Specified by:
    
    currentTimeMillis in interface CurrentTimeProvider
  - getEventloop
```
public Eventloop getEventloop()
```
    Specified by:
    
    getEventloop in interface EventloopJmxMBean
  - submit
```
public CompletableFuture<Void> submit(Runnable runnable)
```
    Submits Runnable to eventloop for execution
    Runnable is executed in the eventloop thread
    
    Specified by:
    
    submit in interface EventloopExecutor
    
    Parameters:
    
    runnable - to be executed
    
    Returns:
    
    CompletableFuture that completes when runnable completes
  - submit
```
public <T> CompletableFuture<T> submit(Callable<T> callable)
```
    Works the same as submit(Runnable) except for Callable
    
    Specified by:
    
    submit in interface EventloopExecutor
  - submit
```
public <T> CompletableFuture<T> submit(AsyncCallable<T> asyncCallable)
```
    Works the same as submit(Runnable) except for AsyncCallable
    
    Specified by:
    
    submit in interface EventloopExecutor
  - setGlobalFatalErrorHandler
```
public static void setGlobalFatalErrorHandler(FatalErrorHandler handler)
```
  - startExtendedMonitoring
```
public void startExtendedMonitoring()
```
  - stopExtendedMonitoring
```
public void stopExtendedMonitoring()
```
  - isExtendedMonitoring
```
public boolean isExtendedMonitoring()
```
  - recordFatalError
```
public void recordFatalError(Throwable e,
                             Object context)
```
  - getLoop
```
public int getLoop()
```
  - getTick
```
public long getTick()
```
  - getFatalErrorHandler
```
public FatalErrorHandler getFatalErrorHandler()
```
  - getThreadPriority
```
public int getThreadPriority()
```
  - getKeepAlive
```
public boolean getKeepAlive()
```
  - getStats
```
public EventloopStats getStats()
```
  - getIdleInterval
```
public Duration getIdleInterval()
```
  - setIdleInterval
```
public void setIdleInterval(Duration idleInterval)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class Eventloop

Nested Class Summary

Field Summary

Fields inherited from interface io.datakernel.time.CurrentTimeProvider

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.datakernel.eventloop.Scheduler

Methods inherited from interface io.datakernel.time.CurrentTimeProvider

Methods inherited from interface io.datakernel.util.Initializable

Methods inherited from interface io.datakernel.jmx.EventloopJmxMBeanEx

Field Detail

CONNECT_TIMEOUT

DEFAULT_IDLE_INTERVAL

Method Detail

create

create

withThreadName

withThreadPriority

withThrottlingController

withFatalErrorHandler

withSelectorProvider

withIdleInterval

withCurrentThread

useCurrentThread

getCurrentEventloop

getThrottlingController

closeChannel

closeChannel

inEventloopThread

keepAlive

breakEventloop

getEventloopThread

run

listen

createDatagramChannel

connect

connect

tick

post

postLater

execute

schedule

scheduleBackground

startExternalTask

completeExternalTask

refreshTimestampAndGet

currentTimeMillis

getEventloop

submit

submit

submit

setGlobalFatalErrorHandler

startExtendedMonitoring

stopExtendedMonitoring

isExtendedMonitoring

recordFatalError

getLoop

getTick

getFatalErrorHandler

getThreadPriority

getKeepAlive

getStats

getIdleInterval

setIdleInterval

toString