Module io.netty5.transport

Package io.netty5.channel

Class SingleThreadEventLoop

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

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 EventLoops, 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 Channels 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.