Class ManualIoEventLoop

java.lang.Object

java.util.concurrent.AbstractExecutorService

io.netty.util.concurrent.AbstractEventExecutor

io.netty.util.concurrent.AbstractScheduledEventExecutor

io.netty.channel.ManualIoEventLoop

All Implemented Interfaces:

EventLoop, EventLoopGroup, IoEventLoop, IoEventLoopGroup, EventExecutor, EventExecutorGroup, OrderedEventExecutor, ThreadAwareExecutor, Iterable<EventExecutor>, Executor, ExecutorService, ScheduledExecutorService

public class ManualIoEventLoop
extends AbstractScheduledEventExecutor
implements IoEventLoop

IoEventLoop implementation that is owned by the user and so needs to be driven by the user manually with the given Thread. This means that the user is responsible to call either runNow() or run(long) to execute IO and tasks that were submitted to this IoEventLoop.

This is for advanced use-cases only, where the user wants to own the Thread that drives the IoEventLoop to also do other work. Care must be taken that the or #waitAndRun() methods are called in a timely fashion.

Nested Class Summary

Nested classes/interfaces inherited from class AbstractEventExecutor

AbstractEventExecutor.LazyRunnable

Constructor Summary

Constructors

Constructor	Description
ManualIoEventLoop(IoEventLoopGroup parent, Thread owningThread, IoHandlerFactory factory)	Create a new IoEventLoop that is owned by the user and so needs to be driven by the user with the given Thread.
ManualIoEventLoop(IoEventLoopGroup parent, Thread owningThread, IoHandlerFactory factory, Ticker ticker)	Create a new IoEventLoop that is owned by the user and so needs to be driven by the user with the given Thread.
ManualIoEventLoop(Thread owningThread, IoHandlerFactory factory)	Create a new IoEventLoop that is owned by the user and so needs to be driven by the user with the given Thread.

Method Summary

Modifier and Type	Method	Description
final boolean	awaitTermination(long timeout, TimeUnit unit)
protected boolean	canBlock()	This allows to specify additional blocking conditions which will be used by the IoHandler to decide whether it is allowed to block or not.
final void	execute(Runnable command)
final boolean	inEventLoop(Thread thread)	Return true if the given Thread is executed in the event loop, false otherwise.
final <T> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> tasks)
final <T> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
final <T> T	invokeAny(Collection<? extends Callable<T>> tasks)
final <T> T	invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
final boolean	isCompatible(Class<? extends IoHandle> handleType)	Returns true if the given type is compatible with this IoEventLoopGroup and so can be registered to the contained IoEventLoops, false otherwise.
final boolean	isIoType(Class<? extends IoHandler> handlerType)	Returns true if the given IoHandler type is used by this IoEventLoopGroup, false otherwise.
final boolean	isShutdown()
final boolean	isShuttingDown()	Returns true if and only if all EventExecutors managed by this EventExecutorGroup are being shut down gracefully or was shut down.
final boolean	isTerminated()
final ManualIoEventLoop	next()	Returns one of the EventExecutors managed by this EventExecutorGroup.
final IoEventLoopGroup	parent()	Return the EventExecutorGroup which is the parent of this EventExecutor,
final ChannelFuture	register(Channel channel)	Deprecated.
final ChannelFuture	register(ChannelPromise promise)	Deprecated.
final ChannelFuture	register(Channel channel, ChannelPromise promise)	Deprecated.
final Future<IoRegistration>	register(IoHandle handle)	Register the IoHandle to the EventLoop for I/O processing.
final int	run(long waitNanos)	Run all ready IO and tasks for this IoEventLoop.
final int	run(long waitNanos, long runAllTasksTimeoutNanos)	Run all ready IO and tasks for this IoEventLoop.
final int	runNonBlockingTasks(long timeoutNanos)	Poll and run tasks from the task queue, until the task queue is empty or the given deadline is exceeded. If timeoutNanos is less or equals 0, no deadline is applied.
final int	runNow()	Run all ready IO and tasks for this IoEventLoop.
final int	runNow(long runAllTasksTimeoutNanos)	Executes all ready IO and tasks for this IoEventLoop.
final void	setOwningThread(Thread owningThread)	Set the owning thread that will call run(IoHandlerContext, long).
final void	shutdown()	Deprecated.
final Future<?>	shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit)	Signals this executor that the caller wants the executor to be shut down.
final Future<?>	terminationFuture()	Returns the Future which is notified when all EventExecutors managed by this EventExecutorGroup have been terminated.
final Ticker	ticker()	The ticker for this executor.
final void	wakeup()	Force a wakeup and so the run(long) method will unblock and return even if there was nothing to do.

Methods inherited from class AbstractScheduledEventExecutor

afterScheduledTaskSubmitted, beforeScheduledTaskSubmitted, cancelScheduledTasks, deadlineToDelayNanos, delayNanos, fetchFromScheduledTaskQueue, getCurrentTimeNanos, hasScheduledTasks, initialNanoTime, nanoTime, nextScheduledTaskDeadlineNanos, nextScheduledTaskNano, pollScheduledTask, pollScheduledTask, schedule, schedule, scheduleAtFixedRate, scheduleWithFixedDelay, validateScheduled

Methods inherited from class AbstractEventExecutor

iterator, lazyExecute, newTaskFor, newTaskFor, runTask, safeExecute, shutdownGracefully, shutdownNow, submit, submit, submit

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface EventExecutor

inEventLoop, isExecutorThread, isSuspended, newFailedFuture, newProgressivePromise, newPromise, newSucceededFuture, trySuspend

Methods inherited from interface EventExecutorGroup

iterator, schedule, schedule, scheduleAtFixedRate, scheduleWithFixedDelay, shutdownGracefully, shutdownNow, submit, submit, submit

Methods inherited from interface Iterable

forEach, spliterator

Constructor Details

ManualIoEventLoop

public ManualIoEventLoop(Thread owningThread,
 IoHandlerFactory factory)

Create a new IoEventLoop that is owned by the user and so needs to be driven by the user with the given Thread. This means that the user is responsible to call either runNow() or run(long) to execute IO or tasks that were submitted to this IoEventLoop.

Parameters:

owningThread - the Thread that executes the IO and tasks for this IoEventLoop. The user will use this Thread to call runNow() or run(long) to make progress.

factory - the IoHandlerFactory that will be used to create the IoHandler that is used by this IoEventLoop.

ManualIoEventLoop

public ManualIoEventLoop(IoEventLoopGroup parent,
 Thread owningThread,
 IoHandlerFactory factory)

Create a new IoEventLoop that is owned by the user and so needs to be driven by the user with the given Thread. This means that the user is responsible to call either runNow() or run(long) to execute IO or tasks that were submitted to this IoEventLoop.

Parameters:

parent - the parent IoEventLoopGroup or null if no parent.

owningThread - the Thread that executes the IO and tasks for this IoEventLoop. The user will use this Thread to call runNow() or run(long) to make progress. If null, must be set later using setOwningThread(Thread).

factory - the IoHandlerFactory that will be used to create the IoHandler that is used by this IoEventLoop.

ManualIoEventLoop

public ManualIoEventLoop(IoEventLoopGroup parent,
 Thread owningThread,
 IoHandlerFactory factory,
 Ticker ticker)

Create a new IoEventLoop that is owned by the user and so needs to be driven by the user with the given Thread. This means that the user is responsible to call either runNow() or run(long) to execute IO or tasks that were submitted to this IoEventLoop.

Parameters:

parent - the parent IoEventLoopGroup or null if no parent.

owningThread - the Thread that executes the IO and tasks for this IoEventLoop. The user will use this Thread to call runNow() or run(long) to make progress. If null, must be set later using setOwningThread(Thread).

factory - the IoHandlerFactory that will be used to create the IoHandler that is used by this IoEventLoop.

ticker - The ticker() to use for this event loop. Note that the IoHandler does not use the ticker, so if the ticker advances faster than system time, you may have to wakeup() this event loop manually.

Method Details

canBlock

protected boolean canBlock()

This allows to specify additional blocking conditions which will be used by the IoHandler to decide whether it is allowed to block or not.

ticker

public final Ticker ticker()

Description copied from interface: EventExecutorGroup

The ticker for this executor. Usually the EventExecutorGroup.schedule(Runnable, long, TimeUnit) methods will follow the system ticker (i.e. System.nanoTime()), but especially for testing it is sometimes useful to have more control over the ticker. In that case, this method will be overridden. Code that schedules tasks on this executor should use this ticker in order to stay consistent with the executor (e.g. not be surprised by scheduled tasks running "early").

Specified by:

ticker in interface EventExecutorGroup

Overrides:

ticker in class AbstractScheduledEventExecutor

Returns:

The ticker for this scheduler

runNonBlockingTasks

public final int runNonBlockingTasks(long timeoutNanos)

Poll and run tasks from the task queue, until the task queue is empty or the given deadline is exceeded.
If timeoutNanos is less or equals 0, no deadline is applied.

Parameters:

timeoutNanos - the maximum time in nanoseconds to run tasks.

runNow

public final int runNow(long runAllTasksTimeoutNanos)

Executes all ready IO and tasks for this IoEventLoop. This methods will NOT block and wait for IO / tasks to be ready, it will just return directly if there is nothing to do.

Must be called from the owning Thread that was passed as a parameter on construction.

Parameters:

runAllTasksTimeoutNanos - the maximum time in nanoseconds to run tasks. If = 0, no timeout is applied; if < 0 it just perform I/O tasks.

Returns:

the number of IO and tasks executed.

Throws:

IllegalStateException - if the method is not called from the owning Thread.

runNow

public final int runNow()

Run all ready IO and tasks for this IoEventLoop. This methods will NOT block and wait for IO / tasks to be ready, it will just return directly if there is nothing to do.

Must be called from the owning Thread that was passed as a parameter on construction.

Returns:

the number of IO and tasks executed.

run

public final int run(long waitNanos,
 long runAllTasksTimeoutNanos)

Run all ready IO and tasks for this IoEventLoop. This methods will block and wait for IO / tasks to be ready if there is nothing to process atm for the given waitNanos.

Must be called from the owning Thread that was passed as an parameter on construction.

Parameters:

waitNanos - the maximum amount of nanoseconds to wait before returning. IF 0 it will block until there is some IO / tasks ready, if -1 will not block at all and just return directly if there is nothing to run (like runNow()).

runAllTasksTimeoutNanos - the maximum time in nanoseconds to run tasks. If = 0, no timeout is applied; if < 0 it just perform I/O tasks.

Returns:

the number of IO and tasks executed.

run

public final int run(long waitNanos)

Run all ready IO and tasks for this IoEventLoop. This methods will block and wait for IO / tasks to be ready if there is nothing to process atm for the given waitNanos.

Must be called from the owning Thread that was passed as an parameter on construction.

Parameters:

waitNanos - the maximum amount of nanoseconds to wait before returning. IF 0 it will block until there is some IO / tasks ready, if -1 will not block at all and just return directly if there is nothing to run (like runNow()).

Returns:

the number of IO and tasks executed.

wakeup

public final void wakeup()

Force a wakeup and so the run(long) method will unblock and return even if there was nothing to do.

next

public final ManualIoEventLoop next()

Description copied from interface: EventExecutorGroup

Returns one of the EventExecutors managed by this EventExecutorGroup.

Specified by:

next in interface EventExecutorGroup

Specified by:

next in interface EventLoopGroup

Specified by:

next in interface IoEventLoop

Specified by:

next in interface IoEventLoopGroup

Overrides:

next in class AbstractEventExecutor

parent

public final IoEventLoopGroup parent()

Description copied from interface: EventExecutor

Return the EventExecutorGroup which is the parent of this EventExecutor,

Specified by:

parent in interface EventExecutor

Specified by:

parent in interface EventLoop

Overrides:

parent in class AbstractEventExecutor

register

@Deprecated
public final ChannelFuture register(Channel channel)

Deprecated.

Description copied from interface: EventLoopGroup

Register a Channel with this EventLoop. The returned ChannelFuture will get notified once the registration was complete.

Specified by:

register in interface EventLoopGroup

Specified by:

register in interface IoEventLoopGroup

register

@Deprecated
public final ChannelFuture register(ChannelPromise promise)

Deprecated.

Description copied from interface: EventLoopGroup

Register a Channel with this EventLoop using a ChannelFuture. The passed ChannelFuture will get notified once the registration was complete and also will get returned.

Specified by:

register in interface EventLoopGroup

Specified by:

register in interface IoEventLoopGroup

register

public final Future<IoRegistration> register(IoHandle handle)

Description copied from interface: IoEventLoop

Register the IoHandle to the EventLoop for I/O processing.

Specified by:

register in interface IoEventLoop

Specified by:

register in interface IoEventLoopGroup

Parameters:

handle - the IoHandle to register.

Returns:

the Future that is notified once the operations completes.

register

@Deprecated
public final ChannelFuture register(Channel channel,
 ChannelPromise promise)

Deprecated.

Description copied from interface: EventLoopGroup

Register a Channel with this EventLoop. The passed ChannelFuture will get notified once the registration was complete and also will get returned.

Specified by:

register in interface EventLoopGroup

isCompatible

public final boolean isCompatible(Class<? extends IoHandle> handleType)

Description copied from interface: IoEventLoopGroup

Returns true if the given type is compatible with this IoEventLoopGroup and so can be registered to the contained IoEventLoops, false otherwise.

Specified by:

isCompatible in interface IoEventLoop

Specified by:

isCompatible in interface IoEventLoopGroup

Parameters:

handleType - the type of the IoHandle.

Returns:

if compatible of not.

isIoType

public final boolean isIoType(Class<? extends IoHandler> handlerType)

Description copied from interface: IoEventLoopGroup

Returns true if the given IoHandler type is used by this IoEventLoopGroup, false otherwise.

Specified by:

isIoType in interface IoEventLoop

Specified by:

isIoType in interface IoEventLoopGroup

Parameters:

handlerType - the type of the IoHandler.

Returns:

if used or not.

inEventLoop

public final boolean inEventLoop(Thread thread)

Description copied from interface: EventExecutor

Return true if the given Thread is executed in the event loop, false otherwise.

Specified by:

inEventLoop in interface EventExecutor

setOwningThread

public final void setOwningThread(Thread owningThread)

Set the owning thread that will call run(IoHandlerContext, long). May only be called once, and only if the owning thread was not set in the constructor already.

Parameters:

owningThread - The owning thread

shutdownGracefully

public final Future<?> shutdownGracefully(long quietPeriod,
 long timeout,
 TimeUnit unit)

Description copied from interface: EventExecutorGroup

Signals this executor that the caller wants the executor to be shut down. Once this method is called, EventExecutorGroup.isShuttingDown() starts to return true, and the executor prepares to shut itself down. Unlike EventExecutorGroup.shutdown(), graceful shutdown ensures that no tasks are submitted for 'the quiet period' (usually a couple seconds) before it shuts itself down. If a task is submitted during the quiet period, it is guaranteed to be accepted and the quiet period will start over.

Specified by:

shutdownGracefully in interface EventExecutorGroup

Parameters:

quietPeriod - the quiet period as described in the documentation

timeout - the maximum amount of time to wait until the executor is EventExecutorGroup.shutdown() regardless if a task was submitted during the quiet period

unit - the unit of quietPeriod and timeout

Returns:

the EventExecutorGroup.terminationFuture()

shutdown

@Deprecated
public final void shutdown()

Deprecated.

Specified by:

shutdown in interface EventExecutorGroup

Specified by:

shutdown in interface ExecutorService

Specified by:

shutdown in class AbstractEventExecutor

terminationFuture

public final Future<?> terminationFuture()

Description copied from interface: EventExecutorGroup

Returns the Future which is notified when all EventExecutors managed by this EventExecutorGroup have been terminated.

Specified by:

terminationFuture in interface EventExecutorGroup

isShuttingDown

public final boolean isShuttingDown()

Description copied from interface: EventExecutorGroup

Returns true if and only if all EventExecutors managed by this EventExecutorGroup are being shut down gracefully or was shut down.

Specified by:

isShuttingDown in interface EventExecutorGroup

isShutdown

public final boolean isShutdown()

Specified by:

isShutdown in interface ExecutorService

isTerminated

public final boolean isTerminated()

Specified by:

isTerminated in interface ExecutorService

awaitTermination

public final boolean awaitTermination(long timeout,
 TimeUnit unit)
                               throws InterruptedException

Specified by:

awaitTermination in interface ExecutorService

Throws:

InterruptedException

execute

public final void execute(Runnable command)

Specified by:

execute in interface Executor

invokeAny

public final <T> T invokeAny(Collection<? extends Callable<T>> tasks)
                      throws InterruptedException,
ExecutionException

Specified by:

invokeAny in interface ExecutorService

Overrides:

invokeAny in class AbstractExecutorService

Throws:

InterruptedException

ExecutionException

invokeAny

public final <T> T invokeAny(Collection<? extends Callable<T>> tasks,
 long timeout,
 TimeUnit unit)
                      throws InterruptedException,
ExecutionException,
TimeoutException

Specified by:

invokeAny in interface ExecutorService

Overrides:

invokeAny in class AbstractExecutorService

Throws:

InterruptedException

ExecutionException

TimeoutException

invokeAll

public final <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
                                    throws InterruptedException

Specified by:

invokeAll in interface ExecutorService

Overrides:

invokeAll in class AbstractExecutorService

Throws:

InterruptedException

invokeAll

public final <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
 long timeout,
 TimeUnit unit)
                                    throws InterruptedException

Specified by:

invokeAll in interface ExecutorService

Overrides:

invokeAll in class AbstractExecutorService

Throws:

InterruptedException