java.lang.Object
- io.netty5.util.concurrent.AbstractEventExecutor
- - io.netty5.util.concurrent.AbstractScheduledEventExecutor
  - - io.netty5.util.concurrent.SingleThreadEventExecutor
    - - io.netty5.channel.SingleThreadEventLoop

All Implemented Interfaces:

EventLoop, EventLoopGroup, EventExecutor, EventExecutorGroup, FuturePromiseFactory, OrderedEventExecutor, Iterable<EventExecutor>, Executor
```
public class SingleThreadEventLoop
extends SingleThreadEventExecutor
implements EventLoop
```
EventLoop that execute all its submitted tasks in a single thread and uses an IoHandler for IO processing.

Field Summary

Fields
Modifier and Type Field Description

protected static int DEFAULT_MAX_PENDING_TASKS

protected static int DEFAULT_MAX_TASKS_PER_RUN
- Fields inherited from class io.netty5.util.concurrent.SingleThreadEventExecutor
  DEFAULT_MAX_PENDING_EXECUTOR_TASKS

Constructor Summary

Constructors
Constructor	Description
`SingleThreadEventLoop(Executor executor, IoHandler ioHandler)`	Create a new instance
`SingleThreadEventLoop(Executor executor, IoHandler ioHandler, int maxPendingTasks, RejectedExecutionHandler rejectedHandler)`	Create a new instance
`SingleThreadEventLoop(Executor executor, IoHandler ioHandler, int maxPendingTasks, RejectedExecutionHandler rejectedHandler, int maxTasksPerRun)`	Create a new instance
`SingleThreadEventLoop(ThreadFactory threadFactory, IoHandler ioHandler)`	Create a new instance
`SingleThreadEventLoop(ThreadFactory threadFactory, IoHandler ioHandler, int maxPendingTasks, RejectedExecutionHandler rejectedHandler)`	Create a new instance
`SingleThreadEventLoop(ThreadFactory threadFactory, IoHandler ioHandler, int maxPendingTasks, RejectedExecutionHandler rejectedHandler, int maxTasksPerRun)`	Create a new instance

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected void`	`cleanup()`	Do nothing, sub-classes may override.
`Future<Void>`	`deregisterForIo(IoHandle handle)`	Deregister the `Channel` from the `EventLoop` for I/O processing.
`boolean`	`isCompatible(Class<? extends IoHandle> handleType)`	Returns `true` if the given type is compatible with this `EventLoopGroup` and so can be registered to the contained `EventLoop`s, `false` otherwise.
`protected Queue<Runnable>`	`newTaskQueue(int maxPendingTasks)`	Create a new `Queue` which will holds the tasks to execute.
`Future<Void>`	`registerForIo(IoHandle handle)`	Register the `IoHandle` to the `EventLoop` for I/O processing.
`protected void`	`run()`	Run tasks that are submitted to this `SingleThreadEventExecutor`.
`protected int`	`runIO()`	Called when IO will be processed for all the `Channel`s on this `SingleThreadEventLoop`.
`protected boolean`	`wakesUpForTask(Runnable task)`	Returns `true` if `SingleThreadEventExecutor.wakeup(boolean)` should be called for this `Runnable`, `false` otherwise.
`protected void`	`wakeup(boolean inEventLoop)`

Methods inherited from class io.netty5.util.concurrent.SingleThreadEventExecutor
addShutdownHook, awaitTermination, confirmShutdown, deadlineNanos, delayNanos, execute, hasTasks, inEventLoop, interruptThread, isShutdown, isShuttingDown, isTerminated, offerTask, pendingTasks, pollTask, reject, removeShutdownHook, removeTask, runAllTasks, shutdownGracefully, takeTask, terminationFuture, threadProperties, updateLastExecutionTime

Methods inherited from class io.netty5.util.concurrent.AbstractScheduledEventExecutor
cancelScheduledTasks, getCurrentTimeNanos, hasScheduledTasks, initialNanoTime, nanoTime, newRunnableScheduledFuture, newScheduledTaskFor, nextScheduledTaskNano, pollScheduledTask, pollScheduledTask, schedule, schedule, schedule, scheduleAtFixedRate, scheduleWithFixedDelay

Methods inherited from class io.netty5.util.concurrent.AbstractEventExecutor
newSucceededFuture, newTaskFor, newTaskFor, submit, submit, submit

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

Methods inherited from interface io.netty5.util.concurrent.EventExecutor
execute, inEventLoop, inEventLoop, iterator, newFailedFuture, newPromise, newSucceededFuture, schedule, schedule, scheduleAtFixedRate, scheduleWithFixedDelay, submit, submit, submit

Methods inherited from interface io.netty5.util.concurrent.EventExecutorGroup
awaitTermination, isShutdown, isShuttingDown, isTerminated, shutdownGracefully, shutdownGracefully, terminationFuture

Methods inherited from interface io.netty5.channel.EventLoop
next

Methods inherited from interface io.netty5.util.concurrent.FuturePromiseFactory
newSucceededFuture

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
  - DEFAULT_MAX_PENDING_TASKS
```
protected static final int DEFAULT_MAX_PENDING_TASKS
```
  - DEFAULT_MAX_TASKS_PER_RUN
```
protected static final int DEFAULT_MAX_TASKS_PER_RUN
```
- Constructor Detail
  - SingleThreadEventLoop
```
public SingleThreadEventLoop(ThreadFactory threadFactory,
                             IoHandler ioHandler)
```
    Create a new instance
    
    Parameters:
    
    threadFactory - the ThreadFactory which will be used for the used Thread
    
    ioHandler - the IoHandler to use.
  - SingleThreadEventLoop
```
public SingleThreadEventLoop(Executor executor,
                             IoHandler ioHandler)
```
    Create a new instance
    
    Parameters:
    
    executor - the Executor which will be used to run this EventLoop.
    
    ioHandler - the IoHandler to use.
  - SingleThreadEventLoop
```
public SingleThreadEventLoop(ThreadFactory threadFactory,
                             IoHandler ioHandler,
                             int maxPendingTasks,
                             RejectedExecutionHandler rejectedHandler)
```
    Create a new instance
    
    Parameters:
    
    threadFactory - the ThreadFactory which will be used for the used Thread
    
    ioHandler - the IoHandler to use.
    
    maxPendingTasks - the maximum number of pending tasks before new tasks will be rejected.
    
    rejectedHandler - the RejectedExecutionHandler to use.
  - SingleThreadEventLoop
```
public SingleThreadEventLoop(Executor executor,
                             IoHandler ioHandler,
                             int maxPendingTasks,
                             RejectedExecutionHandler rejectedHandler)
```
    Create a new instance
    
    Parameters:
    
    executor - the Executor which will be used to run this EventLoop.
    
    ioHandler - the IoHandler to use.
    
    maxPendingTasks - the maximum number of pending tasks before new tasks will be rejected.
    
    rejectedHandler - the RejectedExecutionHandler to use.
  - SingleThreadEventLoop
```
public SingleThreadEventLoop(ThreadFactory threadFactory,
                             IoHandler ioHandler,
                             int maxPendingTasks,
                             RejectedExecutionHandler rejectedHandler,
                             int maxTasksPerRun)
```
    Create a new instance
    
    Parameters:
    
    threadFactory - the ThreadFactory which will be used for the used Thread
    
    ioHandler - the IoHandler to use.
    
    maxPendingTasks - the maximum number of pending tasks before new tasks will be rejected.
    
    rejectedHandler - the RejectedExecutionHandler to use.
    
    maxTasksPerRun - the maximum number of tasks per EventLoop run that will be processed before trying to handle IO again.
  - SingleThreadEventLoop
```
public SingleThreadEventLoop(Executor executor,
                             IoHandler ioHandler,
                             int maxPendingTasks,
                             RejectedExecutionHandler rejectedHandler,
                             int maxTasksPerRun)
```
    Create a new instance
    
    Parameters:
    
    executor - the Executor which will be used to run this EventLoop.
    
    ioHandler - the IoHandler to use.
    
    maxPendingTasks - the maximum number of pending tasks before new tasks will be rejected.
    
    rejectedHandler - the RejectedExecutionHandler to use.
    
    maxTasksPerRun - the maximum number of tasks per EventLoop run that will be processed before trying to handle IO again.
- Method Detail
  - newTaskQueue
```
protected Queue<Runnable> newTaskQueue(int maxPendingTasks)
```
    Description copied from class: SingleThreadEventExecutor
    
    Create a new Queue which will holds the tasks to execute. This default implementation will return a LinkedBlockingQueue but if your sub-class of SingleThreadEventExecutor will not do any blocking calls on the this Queue it may make sense to @Override this and return some more performant implementation that does not support blocking operations at all. Be aware that the implementation of SingleThreadEventExecutor.run() depends on a BlockingQueue so you will need to override SingleThreadEventExecutor.run() as well if you return a non BlockingQueue from this method. As this method is called from within the constructor you can only use the parameters passed into the method when overriding this method.
    
    Overrides:
    
    newTaskQueue in class SingleThreadEventExecutor
  - wakesUpForTask
```
protected final boolean wakesUpForTask(Runnable task)
```
    Description copied from class: SingleThreadEventExecutor
    
    Returns true if SingleThreadEventExecutor.wakeup(boolean) should be called for this Runnable, false otherwise.
    
    Overrides:
    
    wakesUpForTask in class SingleThreadEventExecutor
  - run
```
protected void run()
```
    Description copied from class: SingleThreadEventExecutor
    
    Run tasks that are submitted to this SingleThreadEventExecutor. The implementation depends on the fact that SingleThreadEventExecutor.newTaskQueue(int) returns a BlockingQueue. If you change this by overriding SingleThreadEventExecutor.newTaskQueue(int) be aware that you also need to override SingleThreadEventExecutor.run(). This method must be called from the EventExecutor thread.
    
    Overrides:
    
    run in class SingleThreadEventExecutor
  - runIO
```
protected int runIO()
```
    Called when IO will be processed for all the Channels on this SingleThreadEventLoop. This method returns the number of Channels for which IO was processed. This method must be called from the EventLoop thread.
  - registerForIo
```
public final Future<Void> registerForIo(IoHandle handle)
```
    Description copied from interface: EventLoop
    
    Register the IoHandle to the EventLoop for I/O processing.
    
    Specified by:
    
    registerForIo in interface EventLoop
    
    Parameters:
    
    handle - the IoHandle to register.
    
    Returns:
    
    the Future that is notified once the operations completes.
  - deregisterForIo
```
public final Future<Void> deregisterForIo(IoHandle handle)
```
    Description copied from interface: EventLoop
    
    Deregister the Channel from the EventLoop for I/O processing.
    
    Specified by:
    
    deregisterForIo in interface EventLoop
    
    Returns:
    
    the Future that is notified once the operations completes.
  - wakeup
```
protected final void wakeup(boolean inEventLoop)
```
    Overrides:
    
    wakeup in class SingleThreadEventExecutor
  - cleanup
```
protected final void cleanup()
```
    Description copied from class: SingleThreadEventExecutor
    
    Do nothing, sub-classes may override.
    
    Overrides:
    
    cleanup in class SingleThreadEventExecutor
  - isCompatible
```
public boolean isCompatible(Class<? extends IoHandle> handleType)
```
    Description copied from interface: EventLoopGroup
    
    Returns true if the given type is compatible with this EventLoopGroup and so can be registered to the contained EventLoops, false otherwise.
    
    Specified by:
    
    isCompatible in interface EventLoop
    
    Specified by:
    
    isCompatible in interface EventLoopGroup
    
    Parameters:
    
    handleType - the type of the IoHandle.
    
    Returns:
    
    if compatible of not.

Modifier and Type	Field	Description
`protected static int`	`DEFAULT_MAX_PENDING_TASKS`
`protected static int`	`DEFAULT_MAX_TASKS_PER_RUN`

Class SingleThreadEventLoop

Field Summary

Fields inherited from class io.netty5.util.concurrent.SingleThreadEventExecutor

Constructor Summary

Method Summary

Methods inherited from class io.netty5.util.concurrent.SingleThreadEventExecutor

Methods inherited from class io.netty5.util.concurrent.AbstractScheduledEventExecutor

Methods inherited from class io.netty5.util.concurrent.AbstractEventExecutor

Methods inherited from class java.lang.Object

Methods inherited from interface io.netty5.util.concurrent.EventExecutor

Methods inherited from interface io.netty5.util.concurrent.EventExecutorGroup

Methods inherited from interface io.netty5.channel.EventLoop

Methods inherited from interface io.netty5.util.concurrent.FuturePromiseFactory

Methods inherited from interface java.lang.Iterable

Field Detail

DEFAULT_MAX_PENDING_TASKS

DEFAULT_MAX_TASKS_PER_RUN

Constructor Detail

SingleThreadEventLoop

SingleThreadEventLoop

SingleThreadEventLoop

SingleThreadEventLoop

SingleThreadEventLoop

SingleThreadEventLoop

Method Detail

newTaskQueue

wakesUpForTask

run

runIO

registerForIo

deregisterForIo

wakeup

cleanup

isCompatible