Class GlobalEventExecutor

  • All Implemented Interfaces:
    EventExecutor, EventExecutorGroup, OrderedEventExecutor, java.lang.Iterable<EventExecutor>, java.util.concurrent.Executor, java.util.concurrent.ExecutorService, java.util.concurrent.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.
    • Field Detail

      • SCHEDULE_QUIET_PERIOD_INTERVAL

        private static final long SCHEDULE_QUIET_PERIOD_INTERVAL
      • taskQueue

        final java.util.concurrent.BlockingQueue<java.lang.Runnable> taskQueue
      • threadFactory

        final java.util.concurrent.ThreadFactory threadFactory
      • started

        private final java.util.concurrent.atomic.AtomicBoolean started
      • thread

        volatile java.lang.Thread thread
      • terminationFuture

        private final Future<?> terminationFuture
    • Constructor Detail

      • GlobalEventExecutor

        private GlobalEventExecutor()
    • Method Detail

      • takeTask

        java.lang.Runnable takeTask()
        Take the next Runnable from the task queue and so will block if no task is currently present.
        Returns:
        null if the executor thread has been interrupted or waken up.
      • fetchFromScheduledTaskQueue

        private void fetchFromScheduledTaskQueue()
      • pendingTasks

        public int pendingTasks()
        Return the number of tasks that are pending for processing.
      • addTask

        private void addTask​(java.lang.Runnable task)
        Add a task to the task queue, or throws a RejectedExecutionException if this instance was shutdown before.
      • 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
      • 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()
      • 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)
        Specified by:
        awaitTermination in interface java.util.concurrent.ExecutorService
      • awaitInactivity

        public boolean awaitInactivity​(long timeout,
                                       java.util.concurrent.TimeUnit unit)
                                throws java.lang.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:
        java.lang.InterruptedException
      • execute

        public void execute​(java.lang.Runnable task)
        Specified by:
        execute in interface java.util.concurrent.Executor
      • execute0

        private void execute0​(java.lang.Runnable task)
      • startThread

        private void startThread()