io.netty.util.concurrent

Class SingleThreadEventExecutor

java.lang.Object

java.util.concurrent.AbstractExecutorService

io.netty.util.concurrent.AbstractEventExecutor

io.netty.util.concurrent.SingleThreadEventExecutor

All Implemented Interfaces:

EventExecutor, EventExecutorGroup, Iterable<EventExecutor>, Executor, ExecutorService, ScheduledExecutorService

Direct Known Subclasses:

SingleThreadEventLoop

public abstract class SingleThreadEventExecutor
extends AbstractEventExecutor

Abstract base class for EventExecutor's that execute all its submitted tasks in a single thread.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	SingleThreadEventExecutor(EventExecutorGroup parent, ThreadFactory threadFactory, boolean addTaskWakesUp) Create a new instance

Method Summary

Methods

Modifier and Type	Method and Description
void	addShutdownHook(Runnable task) Add a Runnable which will be executed on shutdown of this instance
protected void	addTask(Runnable task) Add a task to the task queue, or throws a RejectedExecutionException if this instance was shutdown before.
boolean	awaitTermination(long timeout, TimeUnit unit)
protected void	cleanup() Do nothing, sub-classes may override
protected boolean	confirmShutdown() Confirm that the shutdown if the instance should be done now!
protected long	delayNanos(long currentTimeNanos) Returns the amount of time left until the scheduled task with the closest dead line is executed.
void	execute(Runnable task)
protected boolean	hasTasks()
boolean	inEventLoop(Thread thread) Return true if the given Thread is executed in the event loop, false otherwise.
protected void	interruptThread() Interrupt the current running Thread.
boolean	isShutdown()
boolean	isShuttingDown() Returns true if and only if this executor was started to be shut down gracefuclly or was shut down.
boolean	isTerminated()
protected Queue<Runnable>	newTaskQueue() Create a new Queue which will holds the tasks to execute.
EventExecutorGroup	parent() Return the EventExecutorGroup which is the parent of this EventExecutor,
protected Runnable	peekTask()
int	pendingTasks() Return the number of tasks that are pending for processing.
protected Runnable	pollTask()
protected static void	reject()
void	removeShutdownHook(Runnable task) Remove a previous added Runnable as a shutdown hook
protected boolean	removeTask(Runnable task)
protected abstract void	run()
protected boolean	runAllTasks() Poll all tasks from the task queue and run them via Runnable.run() method.
protected boolean	runAllTasks(long timeoutNanos) Poll all tasks from the task queue and run them via Runnable.run() method.
<V> ScheduledFuture<V>	schedule(Callable<V> callable, long delay, TimeUnit unit)
ScheduledFuture<?>	schedule(Runnable command, long delay, TimeUnit unit)
ScheduledFuture<?>	scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
ScheduledFuture<?>	scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
void	shutdown() Deprecated.
Future<?>	shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) Signals this executor that the caller wants the executor to be shut down.
protected Runnable	takeTask() Take the next Runnable from the task queue and so will block if no task is currently present.
Future<?>	terminationFuture() Returns the Future which is notified when this executor has been terminated.
protected void	updateLastExecutionTime() Updates the internal timestamp that tells when a submitted task was executed most recently.
protected void	wakeup(boolean inEventLoop)

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

inEventLoop, iterator, newFailedFuture, newProgressivePromise, newPromise, newSucceededFuture, newTaskFor, newTaskFor, next, shutdownGracefully, shutdownNow, submit, submit, submit

Methods inherited from class java.util.concurrent.AbstractExecutorService

invokeAll, invokeAll, invokeAny, invokeAny

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.concurrent.ExecutorService

invokeAll, invokeAll, invokeAny, invokeAny

Constructor Detail

SingleThreadEventExecutor

protected SingleThreadEventExecutor(EventExecutorGroup parent,
                         ThreadFactory threadFactory,
                         boolean addTaskWakesUp)

Create a new instance

Parameters:

parent - the EventExecutorGroup which is the parent of this instance and belongs to it

threadFactory - the ThreadFactory which will be used for the used Thread

addTaskWakesUp - true if and only if invocation of addTask(Runnable) will wake up the executor thread

Method Detail

newTaskQueue

protected Queue<Runnable> newTaskQueue()

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.

parent

public EventExecutorGroup parent()

Description copied from interface: EventExecutor

Return the EventExecutorGroup which is the parent of this EventExecutor,

interruptThread

protected void interruptThread()

Interrupt the current running Thread.

pollTask

protected Runnable pollTask()

See Also:

Queue#poll()}

takeTask

protected Runnable takeTask()

Take the next Runnable from the task queue and so will block if no task is currently present.

Be aware that this method will throw an UnsupportedOperationException if the task queue, which was created via newTaskQueue(), does not implement BlockingQueue.

Returns:

null if the executor thread has been interrupted or waken up.

peekTask

protected Runnable peekTask()

See Also:

Queue#peek()}

hasTasks

protected boolean hasTasks()

See Also:

Queue#isEmpty()}

pendingTasks

public final int pendingTasks()

Return the number of tasks that are pending for processing. Be aware that this operation may be expensive as it depends on the internal implementation of the SingleThreadEventExecutor. So use it was care!

addTask

protected void addTask(Runnable task)

Add a task to the task queue, or throws a RejectedExecutionException if this instance was shutdown before.

removeTask

protected boolean removeTask(Runnable task)

See Also:

Queue#remove(Object)}

runAllTasks

protected boolean runAllTasks()

Poll all tasks from the task queue and run them via Runnable.run() method.

Returns:

true if and only if at least one task was run

runAllTasks

protected boolean runAllTasks(long timeoutNanos)

Poll all tasks from the task queue and run them via Runnable.run() method. This method stops running the tasks in the task queue and returns if it ran longer than timeoutNanos.

delayNanos

protected long delayNanos(long currentTimeNanos)

Returns the amount of time left until the scheduled task with the closest dead line is executed.

updateLastExecutionTime

protected void updateLastExecutionTime()

Updates the internal timestamp that tells when a submitted task was executed most recently. runAllTasks() and runAllTasks(long) updates this timestamp automatically, and thus there's usually no need to call this method. However, if you take the tasks manually using takeTask() or pollTask(), you have to call this method at the end of task execution loop for accurate quiet period checks.

run

protected abstract void run()

cleanup

protected void cleanup()

Do nothing, sub-classes may override

wakeup

protected void wakeup(boolean inEventLoop)

inEventLoop

public boolean inEventLoop(Thread thread)

Description copied from interface: EventExecutor

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

addShutdownHook

public void addShutdownHook(Runnable task)

Add a Runnable which will be executed on shutdown of this instance

removeShutdownHook

public void removeShutdownHook(Runnable task)

Remove a previous added Runnable as a shutdown hook

shutdownGracefully

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

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()

terminationFuture

public Future<?> terminationFuture()

Description copied from interface: EventExecutorGroup

Returns the Future which is notified when this executor has been terminated.

shutdown

@Deprecated
public void shutdown()

Deprecated.

Specified by:

shutdown in interface EventExecutorGroup

Specified by:

shutdown in interface ExecutorService

Specified by:

shutdown in class AbstractEventExecutor

isShuttingDown

public boolean isShuttingDown()

Description copied from interface: EventExecutorGroup

Returns true if and only if this executor was started to be shut down gracefuclly or was shut down.

isShutdown

public boolean isShutdown()

isTerminated

public boolean isTerminated()

confirmShutdown

protected boolean confirmShutdown()

Confirm that the shutdown if the instance should be done now!

awaitTermination

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

Throws:

InterruptedException

execute

public void execute(Runnable task)

reject

protected static void reject()

schedule

public ScheduledFuture<?> schedule(Runnable command,
                          long delay,
                          TimeUnit unit)

Specified by:

schedule in interface EventExecutorGroup

Specified by:

schedule in interface ScheduledExecutorService

Overrides:

schedule in class AbstractEventExecutor

schedule

public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                              long delay,
                              TimeUnit unit)

Specified by:

schedule in interface EventExecutorGroup

Specified by:

schedule in interface ScheduledExecutorService

Overrides:

schedule in class AbstractEventExecutor

scheduleAtFixedRate

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                     long initialDelay,
                                     long period,
                                     TimeUnit unit)

Specified by:

scheduleAtFixedRate in interface EventExecutorGroup

Specified by:

scheduleAtFixedRate in interface ScheduledExecutorService

Overrides:

scheduleAtFixedRate in class AbstractEventExecutor

scheduleWithFixedDelay

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                        long initialDelay,
                                        long delay,
                                        TimeUnit unit)

Specified by:

scheduleWithFixedDelay in interface EventExecutorGroup

Specified by:

scheduleWithFixedDelay in interface ScheduledExecutorService

Overrides:

scheduleWithFixedDelay in class AbstractEventExecutor