Class GlobalEventExecutor

java.lang.Object

java.util.concurrent.AbstractExecutorService

io.netty.util.concurrent.AbstractEventExecutor

io.netty.util.concurrent.AbstractScheduledEventExecutor

io.netty.util.concurrent.GlobalEventExecutor

All Implemented Interfaces:

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

public final class GlobalEventExecutor
extends AbstractScheduledEventExecutor
implements OrderedEventExecutor

Single-thread singleton EventExecutor. It starts the thread automatically and stops it when there is no task pending in the task queue for io.netty.globalEventExecutor.quietPeriodSeconds second (default is 1 second). Please note it is not scalable to schedule large number of tasks to this executor; use a dedicated executor.

Nested Class Summary

Nested classes/interfaces inherited from class AbstractEventExecutor

AbstractEventExecutor.LazyRunnable

Modifier and Type	Class	Description
static interface	AbstractEventExecutor.LazyRunnable	Deprecated. override SingleThreadEventExecutor.wakesUpForTask(Runnable) to re-create this behaviour

Field Summary

Fields

Modifier and Type	Field	Description
static final GlobalEventExecutor	INSTANCE

Method Summary

Modifier and Type	Method	Description
boolean	awaitInactivity(long timeout, TimeUnit unit)	Waits until the worker thread of this executor has no tasks left in its task queue and terminates itself.
boolean	awaitTermination(long timeout, TimeUnit unit)
void	execute(Runnable task)
boolean	inEventLoop(Thread thread)	Return true if the given Thread is executed in the event loop, 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()
int	pendingTasks()	Return the number of tasks that are pending for processing.
void	shutdown()	Deprecated.
Future<?>	shutdownGracefully(long quietPeriod, long timeout, 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.

Methods inherited from class AbstractScheduledEventExecutor

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

Modifier and Type	Method	Description
protected boolean	afterScheduledTaskSubmitted(long deadlineNanos)	See AbstractScheduledEventExecutor.beforeScheduledTaskSubmitted(long).
protected boolean	beforeScheduledTaskSubmitted(long deadlineNanos)	Called from arbitrary non-EventExecutor threads prior to scheduled task submission.
protected void	cancelScheduledTasks()	Cancel all scheduled tasks.
protected static long	deadlineToDelayNanos(long deadlineNanos)	Given an arbitrary deadline deadlineNanos, calculate the number of nano seconds from now deadlineNanos would expire.
protected long	getCurrentTimeNanos()	Get the current time in nanoseconds by this executor's clock.
protected final boolean	hasScheduledTasks()	Returns true if a scheduled task is ready for processing.
protected static long	initialNanoTime()	The initial value used for delay and computations based upon a monatomic time source.
protected static long	nanoTime()	Deprecated. Use the non-static AbstractScheduledEventExecutor.getCurrentTimeNanos() instead.
protected final long	nextScheduledTaskDeadlineNanos()	Return the deadline (in nanoseconds) when the next scheduled task is ready to be run or -1 if no task is scheduled.
protected final long	nextScheduledTaskNano()	Return the nanoseconds until the next scheduled task is ready to be run or -1 if no task is scheduled.
protected final Runnable	pollScheduledTask()
protected final Runnable	pollScheduledTask(long nanoTime)	Return the Runnable which is ready to be executed with the given nanoTime.
ScheduledFuture<?>	schedule(Runnable command, long delay, TimeUnit unit)
<V> ScheduledFuture<V>	schedule(Callable<V> callable, long delay, TimeUnit unit)
ScheduledFuture<?>	scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
ScheduledFuture<?>	scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
protected void	validateScheduled(long amount, TimeUnit unit)	Deprecated. will be removed in the future.

Methods inherited from class AbstractEventExecutor

inEventLoop, iterator, lazyExecute, newFailedFuture, newProgressivePromise, newPromise, newSucceededFuture, newTaskFor, newTaskFor, next, parent, runTask, safeExecute, shutdownGracefully, shutdownNow, submit, submit, submit

Modifier and Type	Method	Description
boolean	inEventLoop()	Calls EventExecutor.inEventLoop(Thread) with Thread.currentThread() as argument
Iterator<EventExecutor>	iterator()
void	lazyExecute(Runnable task)	Like Executor.execute(Runnable) but does not guarantee the task will be run until either a non-lazy task is executed or the executor is shut down.
<V> Future<V>	newFailedFuture(Throwable cause)	Create a new Future which is marked as failed already.
<V> ProgressivePromise<V>	newProgressivePromise()	Create a new ProgressivePromise.
<V> Promise<V>	newPromise()	Return a new Promise.
<V> Future<V>	newSucceededFuture(V result)	Create a new Future which is marked as succeeded already.
protected final <T> RunnableFuture<T>	newTaskFor(Runnable runnable, T value)
protected final <T> RunnableFuture<T>	newTaskFor(Callable<T> callable)
EventExecutor	next()	Returns a reference to itself.
EventExecutorGroup	parent()	Return the EventExecutorGroup which is the parent of this EventExecutor,
protected static void	runTask(Runnable task)
protected static void	safeExecute(Runnable task)	Try to execute the given Runnable and just log if it throws a Throwable.
Future<?>	shutdownGracefully()	Shortcut method for EventExecutorGroup.shutdownGracefully(long, long, TimeUnit) with sensible default values.
List<Runnable>	shutdownNow()	Deprecated. EventExecutorGroup.shutdownGracefully(long, long, TimeUnit) or AbstractEventExecutor.shutdownGracefully() instead.
Future<?>	submit(Runnable task)
<T> Future<T>	submit(Runnable task, T result)
<T> Future<T>	submit(Callable<T> task)

Methods inherited from class AbstractExecutorService

invokeAll, invokeAll, invokeAny, invokeAny

Methods inherited from class Object

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

Methods inherited from interface Iterable

forEach, spliterator

Field Details

INSTANCE

public static final GlobalEventExecutor INSTANCE

Method Details

pendingTasks

public int pendingTasks()

Return the number of tasks that are pending for processing.

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.

Specified by:

inEventLoop in interface EventExecutor

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.

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

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

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

isTerminated

public boolean isTerminated()

Specified by:

isTerminated in interface ExecutorService

awaitTermination

public boolean awaitTermination(long timeout,
 TimeUnit unit)

Specified by:

awaitTermination in interface ExecutorService

awaitInactivity

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

Waits until the worker thread of this executor has no tasks left in its task queue and terminates itself. Because a new worker thread will be started again when a new task is submitted, this operation is only useful when you want to ensure that the worker thread is terminated after your application is shut down and there's no chance of submitting a new task afterwards.

Returns:

true if and only if the worker thread has been terminated

Throws:

InterruptedException

execute

public void execute(Runnable task)

Specified by:

execute in interface Executor