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, io.netty.util.concurrent.EventExecutor, io.netty.util.concurrent.EventExecutorGroup, io.netty.util.concurrent.OrderedEventExecutor, io.netty.util.concurrent.ThreadAwareExecutor, Iterable<io.netty.util.concurrent.EventExecutor>, Executor, ExecutorService, ScheduledExecutorService

public final class ManualIoEventLoop
extends io.netty.util.concurrent.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

io.netty.util.concurrent.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, io.netty.util.concurrent.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
boolean	awaitTermination(long timeout, TimeUnit unit)
void	execute(Runnable command)
boolean	inEventLoop(Thread thread)
<T> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> tasks)
<T> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
<T> T	invokeAny(Collection<? extends Callable<T>> tasks)
<T> T	invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
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.
boolean	isIoType(Class<? extends IoHandler> handlerType)	Returns true if the given IoHandler type is used by this IoEventLoopGroup, false otherwise.
boolean	isShutdown()
boolean	isShuttingDown()
boolean	isTerminated()
ManualIoEventLoop	next()	Return the next EventLoop to use
IoEventLoopGroup	parent()
ChannelFuture	register(Channel channel)	Deprecated.
ChannelFuture	register(ChannelPromise promise)	Deprecated.
ChannelFuture	register(Channel channel, ChannelPromise promise)	Deprecated.
io.netty.util.concurrent.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	run(long waitNanos, long runAllTasksTimeoutNanos)	Run all ready IO and tasks for this IoEventLoop.
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.
int	runNow()	Run all ready IO and tasks for this IoEventLoop.
int	runNow(long runAllTasksTimeoutNanos)	Executes all ready IO and tasks for this IoEventLoop.
void	setOwningThread(Thread owningThread)	Set the owning thread that will call run(io.netty.channel.IoHandlerContext, long).
void	shutdown()	Deprecated.
io.netty.util.concurrent.Future<?>	shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit)
io.netty.util.concurrent.Future<?>	terminationFuture()
io.netty.util.concurrent.Ticker	ticker()
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(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,
                         io.netty.util.concurrent.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 Detail

ticker

public io.netty.util.concurrent.Ticker ticker()

Specified by:

ticker in interface io.netty.util.concurrent.EventExecutorGroup

Overrides:

ticker in class io.netty.util.concurrent.AbstractScheduledEventExecutor

runNonBlockingTasks

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

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

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.

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. 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 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: EventLoopGroup

Return the next EventLoop to use

Specified by:

next in interface io.netty.util.concurrent.EventExecutorGroup

Specified by:

next in interface EventLoopGroup

Specified by:

next in interface IoEventLoop

Specified by:

next in interface IoEventLoopGroup

Overrides:

next in class io.netty.util.concurrent.AbstractEventExecutor

parent

public IoEventLoopGroup parent()

Specified by:

parent in interface io.netty.util.concurrent.EventExecutor

Specified by:

parent in interface EventLoop

Overrides:

parent in class io.netty.util.concurrent.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 io.netty.util.concurrent.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(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(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(Thread thread)

Specified by:

inEventLoop in interface io.netty.util.concurrent.EventExecutor

setOwningThread

public void setOwningThread(Thread owningThread)

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

Specified by:

shutdownGracefully in interface io.netty.util.concurrent.EventExecutorGroup

shutdown

@Deprecated
public void shutdown()

Deprecated.

Specified by:

shutdown in interface io.netty.util.concurrent.EventExecutorGroup

Specified by:

shutdown in interface ExecutorService

Specified by:

shutdown in class io.netty.util.concurrent.AbstractEventExecutor

terminationFuture

public io.netty.util.concurrent.Future<?> terminationFuture()

Specified by:

terminationFuture in interface io.netty.util.concurrent.EventExecutorGroup

isShuttingDown

public boolean isShuttingDown()

Specified by:

isShuttingDown in interface io.netty.util.concurrent.EventExecutorGroup

isShutdown

public boolean isShutdown()

Specified by:

isShutdown in interface ExecutorService

isTerminated

public boolean isTerminated()

Specified by:

isTerminated in interface ExecutorService

awaitTermination

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

Specified by:

awaitTermination in interface ExecutorService

Throws:

InterruptedException

execute

public void execute(Runnable command)

Specified by:

execute in interface Executor

invokeAny

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