Package io.netty.channel

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, java.lang.Iterable<EventExecutor>, java.util.concurrent.Executor, java.util.concurrent.ExecutorService, java.util.concurrent.ScheduledExecutorService

public final 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 {@link #waitAndRun()} methods are called in a timely fashion.

Nested Class Summary

Nested classes/interfaces inherited from class io.netty.util.concurrent.AbstractEventExecutor

AbstractEventExecutor.LazyRunnable

Constructor Summary

Constructors

Constructor	Description
ManualIoEventLoop(IoEventLoopGroup parent, java.lang.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(java.lang.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
boolean	awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)
void	execute(java.lang.Runnable command)
boolean	inEventLoop(java.lang.Thread thread)	Return true if the given Thread is executed in the event loop, false otherwise.
<T> java.util.List<java.util.concurrent.Future<T>>	invokeAll(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks)
<T> java.util.List<java.util.concurrent.Future<T>>	invokeAll(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks, long timeout, java.util.concurrent.TimeUnit unit)
<T> T	invokeAny(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks)
<T> T	invokeAny(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks, long timeout, java.util.concurrent.TimeUnit unit)
boolean	isCompatible(java.lang.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.
boolean	isIoType(java.lang.Class<? extends IoHandler> handlerType)	Returns true if the given IoHandler type is used by this IoEventLoopGroup, false otherwise.
boolean	isShutdown()
boolean	isShuttingDown()	Returns true if and only if all EventExecutors managed by this EventExecutorGroup are being shut down gracefully or was shut down.
boolean	isTerminated()
ManualIoEventLoop	next()	Returns one of the EventExecutors managed by this EventExecutorGroup.
IoEventLoopGroup	parent()	Return the EventExecutorGroup which is the parent of this EventExecutor,
ChannelFuture	register(Channel channel)	Deprecated.
ChannelFuture	register(ChannelPromise promise)	Deprecated.
ChannelFuture	register(Channel channel, ChannelPromise promise)	Deprecated.
Future<IoRegistration>	register(IoHandle handle)	Register the IoHandle to the EventLoop for I/O processing.
int	run(long waitNanos)	Run all ready IO and tasks for this IoEventLoop.
int	runNow()	Run all ready IO and tasks for this IoEventLoop.
void	setOwningThread(java.lang.Thread owningThread)	Set the owning thread that will call run(io.netty.channel.IoHandlerContext).
void	shutdown()	Deprecated.
Future<?>	shutdownGracefully(long quietPeriod, long timeout, java.util.concurrent.TimeUnit unit)	Signals this executor that the caller wants the executor to be shut down.
Future<?>	terminationFuture()	Returns the Future which is notified when all EventExecutors managed by this EventExecutorGroup have been terminated.
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 io.netty.util.concurrent.AbstractScheduledEventExecutor

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

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

iterator, lazyExecute, newTaskFor, newTaskFor, runTask, safeExecute, shutdownGracefully, shutdownNow, 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.netty.util.concurrent.EventExecutor

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

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

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

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Constructor Detail

ManualIoEventLoop

public ManualIoEventLoop(java.lang.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,
                         java.lang.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.

Method Detail

runNow

public 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 an parameter on construction.

Returns:

the number of IO and tasks executed.

run

public 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.

Returns:

the number of IO and tasks executed.

wakeup

public void wakeup()

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

next

public 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 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 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 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 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 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 boolean isCompatible(java.lang.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 boolean isIoType(java.lang.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 boolean inEventLoop(java.lang.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 void setOwningThread(java.lang.Thread owningThread)

Set the owning thread that will call run(io.netty.channel.IoHandlerContext). 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 Future<?> shutdownGracefully(long quietPeriod,
                                    long timeout,
                                    java.util.concurrent.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 void shutdown()

Deprecated.

Specified by:

shutdown in interface EventExecutorGroup

Specified by:

shutdown in interface java.util.concurrent.ExecutorService

Specified by:

shutdown in class AbstractEventExecutor

terminationFuture

public 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 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 boolean isShutdown()

Specified by:

isShutdown in interface java.util.concurrent.ExecutorService

isTerminated

public boolean isTerminated()

Specified by:

isTerminated in interface java.util.concurrent.ExecutorService

awaitTermination

public boolean awaitTermination(long timeout,
                                java.util.concurrent.TimeUnit unit)
                         throws java.lang.InterruptedException

Specified by:

awaitTermination in interface java.util.concurrent.ExecutorService

Throws:

java.lang.InterruptedException

execute

public void execute(java.lang.Runnable command)

Specified by:

execute in interface java.util.concurrent.Executor

invokeAny

public <T> T invokeAny(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks)
                throws java.lang.InterruptedException,
                       java.util.concurrent.ExecutionException

Specified by:

invokeAny in interface java.util.concurrent.ExecutorService

Overrides:

invokeAny in class java.util.concurrent.AbstractExecutorService

Throws:

java.lang.InterruptedException

java.util.concurrent.ExecutionException

invokeAny

public <T> T invokeAny(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks,
                       long timeout,
                       java.util.concurrent.TimeUnit unit)
                throws java.lang.InterruptedException,
                       java.util.concurrent.ExecutionException,
                       java.util.concurrent.TimeoutException

Specified by:

invokeAny in interface java.util.concurrent.ExecutorService

Overrides:

invokeAny in class java.util.concurrent.AbstractExecutorService

Throws:

java.lang.InterruptedException

java.util.concurrent.ExecutionException

java.util.concurrent.TimeoutException

invokeAll

public <T> java.util.List<java.util.concurrent.Future<T>> invokeAll(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks)
                                                             throws java.lang.InterruptedException

Specified by:

invokeAll in interface java.util.concurrent.ExecutorService

Overrides:

invokeAll in class java.util.concurrent.AbstractExecutorService

Throws:

java.lang.InterruptedException

invokeAll

public <T> java.util.List<java.util.concurrent.Future<T>> invokeAll(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks,
                                                                    long timeout,
                                                                    java.util.concurrent.TimeUnit unit)
                                                             throws java.lang.InterruptedException

Specified by:

invokeAll in interface java.util.concurrent.ExecutorService

Overrides:

invokeAll in class java.util.concurrent.AbstractExecutorService

Throws:

java.lang.InterruptedException