java.lang.Object
- java.util.concurrent.AbstractExecutorService
- - io.netty.util.concurrent.AbstractEventExecutor
  - - io.netty.util.concurrent.AbstractScheduledEventExecutor
    - - io.netty.util.concurrent.SingleThreadEventExecutor

All Implemented Interfaces:

EventExecutor, EventExecutorGroup, OrderedEventExecutor, ThreadAwareExecutor, java.lang.Iterable<EventExecutor>, java.util.concurrent.Executor, java.util.concurrent.ExecutorService, java.util.concurrent.ScheduledExecutorService

Direct Known Subclasses:

DefaultEventExecutor, SingleThreadEventLoop
```
public abstract class SingleThreadEventExecutor
extends AbstractScheduledEventExecutor
implements OrderedEventExecutor
```
Abstract base class for OrderedEventExecutor's that execute all its submitted tasks in a single thread.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`private static class`	`SingleThreadEventExecutor.DefaultThreadProperties`
`protected static interface`	`SingleThreadEventExecutor.NonWakeupRunnable`	Deprecated. override `wakesUpForTask(java.lang.Runnable)` to re-create this behaviour

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

Field Summary

Fields
Modifier and Type	Field	Description
`private static java.util.concurrent.atomic.AtomicLongFieldUpdater<SingleThreadEventExecutor>`	`ACCUMULATED_ACTIVE_TIME_NANOS_UPDATER`
`private long`	`accumulatedActiveTimeNanos`
`private boolean`	`addTaskWakesUp`
`private static java.util.concurrent.atomic.AtomicIntegerFieldUpdater<SingleThreadEventExecutor>`	`CONSECUTIVE_BUSY_CYCLES_UPDATER`
`private static java.util.concurrent.atomic.AtomicIntegerFieldUpdater<SingleThreadEventExecutor>`	`CONSECUTIVE_IDLE_CYCLES_UPDATER`
`private int`	`consecutiveBusyCycles`	Tracks the number of consecutive monitor cycles this executor's utilization has been above the scale-up threshold.
`private int`	`consecutiveIdleCycles`	Tracks the number of consecutive monitor cycles this executor's utilization has been below the scale-down threshold.
`(package private) static int`	`DEFAULT_MAX_PENDING_EXECUTOR_TASKS`
`private java.util.concurrent.Executor`	`executor`
`private long`	`gracefulShutdownQuietPeriod`
`private long`	`gracefulShutdownStartTime`
`private long`	`gracefulShutdownTimeout`
`private boolean`	`interrupted`
`private long`	`lastActivityTimeNanos`
`private long`	`lastExecutionTime`
`private static InternalLogger`	`logger`
`private int`	`maxPendingTasks`
`private static java.lang.Runnable`	`NOOP_TASK`
`private java.util.concurrent.locks.Lock`	`processingLock`
`private static java.util.concurrent.atomic.AtomicReferenceFieldUpdater<SingleThreadEventExecutor,ThreadProperties>`	`PROPERTIES_UPDATER`
`private RejectedExecutionHandler`	`rejectedExecutionHandler`
`private static long`	`SCHEDULE_PURGE_INTERVAL`
`private java.util.Set<java.lang.Runnable>`	`shutdownHooks`
`private static int`	`ST_NOT_STARTED`
`private static int`	`ST_SHUTDOWN`
`private static int`	`ST_SHUTTING_DOWN`
`private static int`	`ST_STARTED`
`private static int`	`ST_SUSPENDED`
`private static int`	`ST_SUSPENDING`
`private static int`	`ST_TERMINATED`
`private int`	`state`
`private static java.util.concurrent.atomic.AtomicIntegerFieldUpdater<SingleThreadEventExecutor>`	`STATE_UPDATER`
`private boolean`	`supportSuspension`
`private java.util.Queue<java.lang.Runnable>`	`taskQueue`
`private Promise<?>`	`terminationFuture`
`private java.lang.Thread`	`thread`
`private java.util.concurrent.CountDownLatch`	`threadLock`
`private ThreadProperties`	`threadProperties`

Fields inherited from class io.netty.util.concurrent.AbstractScheduledEventExecutor
nextTaskId, scheduledTaskQueue, WAKEUP_TASK

Fields inherited from class io.netty.util.concurrent.AbstractEventExecutor
DEFAULT_SHUTDOWN_QUIET_PERIOD, DEFAULT_SHUTDOWN_TIMEOUT

Constructor Summary

Constructors
Modifier	Constructor	Description
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, java.util.concurrent.Executor executor, boolean addTaskWakesUp)`	Create a new instance
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, java.util.concurrent.Executor executor, boolean addTaskWakesUp, boolean supportSuspension, int maxPendingTasks, RejectedExecutionHandler rejectedHandler)`	Create a new instance
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, java.util.concurrent.Executor executor, boolean addTaskWakesUp, boolean supportSuspension, java.util.Queue<java.lang.Runnable> taskQueue, RejectedExecutionHandler rejectedHandler)`
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, java.util.concurrent.Executor executor, boolean addTaskWakesUp, int maxPendingTasks, RejectedExecutionHandler rejectedHandler)`	Create a new instance
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, java.util.concurrent.Executor executor, boolean addTaskWakesUp, java.util.Queue<java.lang.Runnable> taskQueue, RejectedExecutionHandler rejectedHandler)`
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, java.util.concurrent.ThreadFactory threadFactory, boolean addTaskWakesUp)`	Create a new instance
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, java.util.concurrent.ThreadFactory threadFactory, boolean addTaskWakesUp, boolean supportSuspension, int maxPendingTasks, RejectedExecutionHandler rejectedHandler)`	Create a new instance
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, java.util.concurrent.ThreadFactory threadFactory, boolean addTaskWakesUp, int maxPendingTasks, RejectedExecutionHandler rejectedHandler)`	Create a new instance

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`void`	`addShutdownHook(java.lang.Runnable task)`	Add a `Runnable` which will be executed on shutdown of this instance
`protected void`	`addTask(java.lang.Runnable task)`	Add a task to the task queue, or throws a `RejectedExecutionException` if this instance was shutdown before.
`protected void`	`afterRunningAllTasks()`	Invoked before returning from `runAllTasks()` and `runAllTasks(long)`.
`boolean`	`awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)`
`protected boolean`	`canSuspend()`	Returns `true` if this `SingleThreadEventExecutor` can be suspended at the moment, `false` otherwise.
`protected boolean`	`canSuspend(int state)`	Returns `true` if this `SingleThreadEventExecutor` can be suspended at the moment, `false` otherwise.
`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`	`deadlineNanos()`	Returns the absolute point in time (relative to `AbstractScheduledEventExecutor.getCurrentTimeNanos()`) at which the next closest scheduled task should run.
`protected long`	`delayNanos(long currentTimeNanos)`	Returns the amount of time left until the scheduled task with the closest dead line is executed.
`private void`	`doStartThread()`
`(package private) int`	`drainTasks()`
`private boolean`	`ensureThreadStarted(int oldState)`
`void`	`execute(java.lang.Runnable task)`
`private void`	`execute(java.lang.Runnable task, boolean immediate)`
`private void`	`execute0(java.lang.Runnable task)`
`private boolean`	`executeExpiredScheduledTasks()`
`private boolean`	`fetchFromScheduledTaskQueue()`
`protected int`	`getAndIncrementBusyCycles()`	Atomically increments the counter for consecutive monitor cycles where utilization was above the scale-up threshold.
`protected int`	`getAndIncrementIdleCycles()`	Atomically increments the counter for consecutive monitor cycles where utilization was below the scale-down threshold.
`protected long`	`getAndResetAccumulatedActiveTimeNanos()`	Returns the accumulated active time since the last call and resets the counter.
`protected long`	`getLastActivityTimeNanos()`	Returns the timestamp of the last known activity (tasks + I/O).
`protected int`	`getNumOfRegisteredChannels()`	Returns the number of registered channels for auto-scaling related decisions.
`protected boolean`	`hasTasks()`
`boolean`	`inEventLoop(java.lang.Thread thread)`	Return `true` if the given `Thread` is executed in the event loop, `false` otherwise.
`protected void`	`interruptThread()`	Interrupt the current running `Thread`.
`<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`	`isShutdown()`
`boolean`	`isShuttingDown()`	Returns `true` if and only if all `EventExecutor`s managed by this `EventExecutorGroup` are being shut down gracefully or was shut down.
`boolean`	`isSuspended()`	Returns `true` if the `EventExecutor` is considered suspended.
`protected boolean`	`isSuspensionSupported()`	Returns `true` if this `SingleThreadEventExecutor` supports suspension.
`boolean`	`isTerminated()`
`void`	`lazyExecute(java.lang.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.
`private void`	`lazyExecute0(java.lang.Runnable task)`
`protected java.util.Queue<java.lang.Runnable>`	`newTaskQueue()`	Deprecated. Please use and override `newTaskQueue(int)`.
`protected java.util.Queue<java.lang.Runnable>`	`newTaskQueue(int maxPendingTasks)`	Create a new `Queue` which will holds the tasks to execute.
`(package private) boolean`	`offerTask(java.lang.Runnable task)`
`protected java.lang.Runnable`	`peekTask()`
`int`	`pendingTasks()`	Return the number of tasks that are pending for processing.
`protected java.lang.Runnable`	`pollTask()`
`protected static java.lang.Runnable`	`pollTaskFrom(java.util.Queue<java.lang.Runnable> taskQueue)`
`protected static void`	`reject()`
`protected void`	`reject(java.lang.Runnable task)`	Offers the task to the associated `RejectedExecutionHandler`.
`void`	`removeShutdownHook(java.lang.Runnable task)`	Remove a previous added `Runnable` as a shutdown hook
`protected boolean`	`removeTask(java.lang.Runnable task)`
`protected void`	`reportActiveIoTime(long nanos)`	Adds the given duration to the total active time for the current measurement window.
`protected void`	`resetBusyCycles()`	Resets the counter for consecutive busy cycles to zero.
`protected void`	`resetIdleCycles()`	Resets the counter for consecutive idle cycles to zero.
`protected abstract void`	`run()`	Runs the task-processing loop until `confirmShutdown()` returns `true`.
`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.
`protected boolean`	`runAllTasksFrom(java.util.Queue<java.lang.Runnable> taskQueue)`	Runs all tasks from the passed `taskQueue`.
`private boolean`	`runExistingTasksFrom(java.util.Queue<java.lang.Runnable> taskQueue)`	What ever tasks are present in `taskQueue` when this method is invoked will be `Runnable.run()`.
`protected boolean`	`runScheduledAndExecutorTasks(int maxDrainAttempts)`	Execute all expired scheduled tasks and all current tasks in the executor queue until both queues are empty, or `maxDrainAttempts` has been exceeded.
`private boolean`	`runShutdownHooks()`
`(package private) void`	`scheduleRemoveScheduled(ScheduledFutureTask<?> task)`
`void`	`shutdown()`	Deprecated.
`private void`	`shutdown0(long quietPeriod, long timeout, int shutdownState)`
`Future<?>`	`shutdownGracefully(long quietPeriod, long timeout, java.util.concurrent.TimeUnit unit)`	Signals this executor that the caller wants the executor to be shut down.
`private void`	`startThread()`
`protected java.lang.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 all `EventExecutor`s managed by this `EventExecutorGroup` have been terminated.
`ThreadProperties`	`threadProperties()`	Returns the `ThreadProperties` of the `Thread` that powers the `SingleThreadEventExecutor`.
`private void`	`throwIfInEventLoop(java.lang.String method)`
`boolean`	`trySuspend()`	Try to suspend this `EventExecutor` and return `true` if suspension was successful.
`protected void`	`updateLastExecutionTime()`	Updates the internal timestamp that tells when a submitted task was executed most recently.
`protected boolean`	`wakesUpForTask(java.lang.Runnable task)`	Can be overridden to control which tasks require waking the `EventExecutor` thread if it is waiting so that they can be run immediately.
`protected void`	`wakeup(boolean inEventLoop)`

Methods inherited from class io.netty.util.concurrent.AbstractEventExecutor
iterator, newTaskFor, newTaskFor, next, parent, 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, newFailedFuture, newProgressivePromise, newPromise, newSucceededFuture, parent

Methods inherited from interface io.netty.util.concurrent.EventExecutorGroup
iterator, next, schedule, schedule, scheduleAtFixedRate, scheduleWithFixedDelay, shutdownGracefully, shutdownNow, submit, submit, submit, ticker

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Field Detail
  - DEFAULT_MAX_PENDING_EXECUTOR_TASKS
```
static final int DEFAULT_MAX_PENDING_EXECUTOR_TASKS
```
  - logger
```
private static final InternalLogger logger
```
  - ST_NOT_STARTED
```
private static final int ST_NOT_STARTED
```
    See Also:
    
    Constant Field Values
  - ST_SUSPENDING
```
private static final int ST_SUSPENDING
```
    See Also:
    
    Constant Field Values
  - ST_SUSPENDED
```
private static final int ST_SUSPENDED
```
    See Also:
    
    Constant Field Values
  - ST_STARTED
```
private static final int ST_STARTED
```
    See Also:
    
    Constant Field Values
  - ST_SHUTTING_DOWN
```
private static final int ST_SHUTTING_DOWN
```
    See Also:
    
    Constant Field Values
  - ST_SHUTDOWN
```
private static final int ST_SHUTDOWN
```
    See Also:
    
    Constant Field Values
  - ST_TERMINATED
```
private static final int ST_TERMINATED
```
    See Also:
    
    Constant Field Values
  - NOOP_TASK
```
private static final java.lang.Runnable NOOP_TASK
```
  - STATE_UPDATER
```
private static final java.util.concurrent.atomic.AtomicIntegerFieldUpdater<SingleThreadEventExecutor> STATE_UPDATER
```
  - PROPERTIES_UPDATER
```
private static final java.util.concurrent.atomic.AtomicReferenceFieldUpdater<SingleThreadEventExecutor,ThreadProperties> PROPERTIES_UPDATER
```
  - ACCUMULATED_ACTIVE_TIME_NANOS_UPDATER
```
private static final java.util.concurrent.atomic.AtomicLongFieldUpdater<SingleThreadEventExecutor> ACCUMULATED_ACTIVE_TIME_NANOS_UPDATER
```
  - CONSECUTIVE_IDLE_CYCLES_UPDATER
```
private static final java.util.concurrent.atomic.AtomicIntegerFieldUpdater<SingleThreadEventExecutor> CONSECUTIVE_IDLE_CYCLES_UPDATER
```
  - CONSECUTIVE_BUSY_CYCLES_UPDATER
```
private static final java.util.concurrent.atomic.AtomicIntegerFieldUpdater<SingleThreadEventExecutor> CONSECUTIVE_BUSY_CYCLES_UPDATER
```
  - taskQueue
```
private final java.util.Queue<java.lang.Runnable> taskQueue
```
  - thread
```
private volatile java.lang.Thread thread
```
  - threadProperties
```
private volatile ThreadProperties threadProperties
```
  - executor
```
private final java.util.concurrent.Executor executor
```
  - interrupted
```
private volatile boolean interrupted
```
  - processingLock
```
private final java.util.concurrent.locks.Lock processingLock
```
  - threadLock
```
private final java.util.concurrent.CountDownLatch threadLock
```
  - shutdownHooks
```
private final java.util.Set<java.lang.Runnable> shutdownHooks
```
  - addTaskWakesUp
```
private final boolean addTaskWakesUp
```
  - maxPendingTasks
```
private final int maxPendingTasks
```
  - rejectedExecutionHandler
```
private final RejectedExecutionHandler rejectedExecutionHandler
```
  - supportSuspension
```
private final boolean supportSuspension
```
  - accumulatedActiveTimeNanos
```
private volatile long accumulatedActiveTimeNanos
```
  - lastActivityTimeNanos
```
private volatile long lastActivityTimeNanos
```
  - consecutiveIdleCycles
```
private volatile int consecutiveIdleCycles
```
    Tracks the number of consecutive monitor cycles this executor's utilization has been below the scale-down threshold.
  - consecutiveBusyCycles
```
private volatile int consecutiveBusyCycles
```
    Tracks the number of consecutive monitor cycles this executor's utilization has been above the scale-up threshold.
  - lastExecutionTime
```
private long lastExecutionTime
```
  - state
```
private volatile int state
```
  - gracefulShutdownQuietPeriod
```
private volatile long gracefulShutdownQuietPeriod
```
  - gracefulShutdownTimeout
```
private volatile long gracefulShutdownTimeout
```
  - gracefulShutdownStartTime
```
private long gracefulShutdownStartTime
```
  - terminationFuture
```
private final Promise<?> terminationFuture
```
  - SCHEDULE_PURGE_INTERVAL
```
private static final long SCHEDULE_PURGE_INTERVAL
```
- Constructor Detail
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                                    java.util.concurrent.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
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                                    java.util.concurrent.ThreadFactory threadFactory,
                                    boolean addTaskWakesUp,
                                    int maxPendingTasks,
                                    RejectedExecutionHandler rejectedHandler)
```
    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
    
    maxPendingTasks - the maximum number of pending tasks before new tasks will be rejected.
    
    rejectedHandler - the RejectedExecutionHandler to use.
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                                    java.util.concurrent.ThreadFactory threadFactory,
                                    boolean addTaskWakesUp,
                                    boolean supportSuspension,
                                    int maxPendingTasks,
                                    RejectedExecutionHandler rejectedHandler)
```
    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
    
    supportSuspension - true if suspension of this SingleThreadEventExecutor is supported.
    
    maxPendingTasks - the maximum number of pending tasks before new tasks will be rejected.
    
    rejectedHandler - the RejectedExecutionHandler to use.
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                                    java.util.concurrent.Executor executor,
                                    boolean addTaskWakesUp)
```
    Create a new instance
    
    Parameters:
    
    parent - the EventExecutorGroup which is the parent of this instance and belongs to it
    
    executor - the Executor which will be used for executing
    
    addTaskWakesUp - true if and only if invocation of addTask(Runnable) will wake up the executor thread
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                                    java.util.concurrent.Executor executor,
                                    boolean addTaskWakesUp,
                                    int maxPendingTasks,
                                    RejectedExecutionHandler rejectedHandler)
```
    Create a new instance
    
    Parameters:
    
    parent - the EventExecutorGroup which is the parent of this instance and belongs to it
    
    executor - the Executor which will be used for executing
    
    addTaskWakesUp - true if and only if invocation of addTask(Runnable) will wake up the executor thread
    
    maxPendingTasks - the maximum number of pending tasks before new tasks will be rejected.
    
    rejectedHandler - the RejectedExecutionHandler to use.
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                                    java.util.concurrent.Executor executor,
                                    boolean addTaskWakesUp,
                                    boolean supportSuspension,
                                    int maxPendingTasks,
                                    RejectedExecutionHandler rejectedHandler)
```
    Create a new instance
    
    Parameters:
    
    parent - the EventExecutorGroup which is the parent of this instance and belongs to it
    
    executor - the Executor which will be used for executing
    
    addTaskWakesUp - true if and only if invocation of addTask(Runnable) will wake up the executor thread
    
    supportSuspension - true if suspension of this SingleThreadEventExecutor is supported.
    
    maxPendingTasks - the maximum number of pending tasks before new tasks will be rejected.
    
    rejectedHandler - the RejectedExecutionHandler to use.
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                                    java.util.concurrent.Executor executor,
                                    boolean addTaskWakesUp,
                                    java.util.Queue<java.lang.Runnable> taskQueue,
                                    RejectedExecutionHandler rejectedHandler)
```
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                                    java.util.concurrent.Executor executor,
                                    boolean addTaskWakesUp,
                                    boolean supportSuspension,
                                    java.util.Queue<java.lang.Runnable> taskQueue,
                                    RejectedExecutionHandler rejectedHandler)
```
- Method Detail
  - newTaskQueue
```
@Deprecated
protected java.util.Queue<java.lang.Runnable> newTaskQueue()
```
    Deprecated.
    Please use and override newTaskQueue(int).
  - newTaskQueue
```
protected java.util.Queue<java.lang.Runnable> newTaskQueue(int maxPendingTasks)
```
    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.
  - interruptThread
```
protected void interruptThread()
```
    Interrupt the current running Thread.
  - pollTask
```
protected java.lang.Runnable pollTask()
```
    See Also:
    
    Queue.poll()
  - pollTaskFrom
```
protected static java.lang.Runnable pollTaskFrom(java.util.Queue<java.lang.Runnable> taskQueue)
```
  - takeTask
```
protected java.lang.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.
  - fetchFromScheduledTaskQueue
```
private boolean fetchFromScheduledTaskQueue()
```
  - executeExpiredScheduledTasks
```
private boolean executeExpiredScheduledTasks()
```
    Returns:
    
    true if at least one scheduled task was executed.
  - peekTask
```
protected java.lang.Runnable peekTask()
```
    See Also:
    
    Queue.peek()
  - hasTasks
```
protected boolean hasTasks()
```
    See Also:
    
    Collection.isEmpty()
  - pendingTasks
```
public int pendingTasks()
```
    Return the number of tasks that are pending for processing.
  - addTask
```
protected void addTask(java.lang.Runnable task)
```
    Add a task to the task queue, or throws a RejectedExecutionException if this instance was shutdown before.
  - offerTask
```
final boolean offerTask(java.lang.Runnable task)
```
  - removeTask
```
protected boolean removeTask(java.lang.Runnable task)
```
    See Also:
    
    Collection.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
  - runScheduledAndExecutorTasks
```
protected final boolean runScheduledAndExecutorTasks(int maxDrainAttempts)
```
    Execute all expired scheduled tasks and all current tasks in the executor queue until both queues are empty, or maxDrainAttempts has been exceeded.
    
    Parameters:
    
    maxDrainAttempts - The maximum amount of times this method attempts to drain from queues. This is to prevent continuous task execution and scheduling from preventing the EventExecutor thread to make progress and return to the selector mechanism to process inbound I/O events.
    
    Returns:
    
    true if at least one task was run.
  - runAllTasksFrom
```
protected final boolean runAllTasksFrom(java.util.Queue<java.lang.Runnable> taskQueue)
```
    Runs all tasks from the passed taskQueue.
    
    Parameters:
    
    taskQueue - To poll and execute all tasks.
    
    Returns:
    
    true if at least one task was executed.
  - runExistingTasksFrom
```
private boolean runExistingTasksFrom(java.util.Queue<java.lang.Runnable> taskQueue)
```
    What ever tasks are present in taskQueue when this method is invoked will be Runnable.run().
    
    Parameters:
    
    taskQueue - the task queue to drain.
    
    Returns:
    
    true if at least Runnable.run() was called.
  - 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.
  - afterRunningAllTasks
```
protected void afterRunningAllTasks()
```
    Invoked before returning from runAllTasks() and runAllTasks(long).
  - delayNanos
```
protected long delayNanos(long currentTimeNanos)
```
    Returns the amount of time left until the scheduled task with the closest dead line is executed.
  - deadlineNanos
```
protected long deadlineNanos()
```
    Returns the absolute point in time (relative to AbstractScheduledEventExecutor.getCurrentTimeNanos()) at which the next closest scheduled task should run.
  - 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.
  - getNumOfRegisteredChannels
```
protected int getNumOfRegisteredChannels()
```
    Returns the number of registered channels for auto-scaling related decisions. This is intended to be used by MultithreadEventExecutorGroup for dynamic scaling.
    
    Returns:
    
    The number of registered channels, or -1 if not applicable.
  - reportActiveIoTime
```
protected void reportActiveIoTime(long nanos)
```
    Adds the given duration to the total active time for the current measurement window.
    Note: This method is not thread-safe and must only be called from the event loop thread.
    
    Parameters:
    
    nanos - The active time in nanoseconds to add.
  - getAndResetAccumulatedActiveTimeNanos
```
protected long getAndResetAccumulatedActiveTimeNanos()
```
    Returns the accumulated active time since the last call and resets the counter.
  - getLastActivityTimeNanos
```
protected long getLastActivityTimeNanos()
```
    Returns the timestamp of the last known activity (tasks + I/O).
  - getAndIncrementIdleCycles
```
protected int getAndIncrementIdleCycles()
```
    Atomically increments the counter for consecutive monitor cycles where utilization was below the scale-down threshold. This is used by the auto-scaling monitor to track sustained idleness.
    
    Returns:
    
    The number of consecutive idle cycles before the increment.
  - resetIdleCycles
```
protected void resetIdleCycles()
```
    Resets the counter for consecutive idle cycles to zero. This is typically called when the executor's utilization is no longer considered idle, breaking the streak.
  - getAndIncrementBusyCycles
```
protected int getAndIncrementBusyCycles()
```
    Atomically increments the counter for consecutive monitor cycles where utilization was above the scale-up threshold. This is used by the auto-scaling monitor to track a sustained high load.
    
    Returns:
    
    The number of consecutive busy cycles before the increment.
  - resetBusyCycles
```
protected void resetBusyCycles()
```
    Resets the counter for consecutive busy cycles to zero. This is typically called when the executor's utilization is no longer considered busy, breaking the streak.
  - isSuspensionSupported
```
protected boolean isSuspensionSupported()
```
    Returns true if this SingleThreadEventExecutor supports suspension.
  - run
```
protected abstract void run()
```
    Runs the task-processing loop until confirmShutdown() returns true.
    Implementations must not let a Throwable thrown by a task escape this method: any uncaught Throwable terminates the executor (logged at WARN and surfaced via terminationFuture()), at which point every Channel registered with this executor stops processing I/O and new task submissions are rejected. The supplied helpers - runAllTasks(), runAllTasks(long), and AbstractEventExecutor.safeExecute(Runnable) - catch Throwable for you; custom loops built on pollTask() or takeTask() are responsible for wrapping each task invocation accordingly.
  - cleanup
```
protected void cleanup()
```
    Do nothing, sub-classes may override
  - wakeup
```
protected void wakeup(boolean inEventLoop)
```
  - 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
  - addShutdownHook
```
public void addShutdownHook(java.lang.Runnable task)
```
    Add a Runnable which will be executed on shutdown of this instance
  - removeShutdownHook
```
public void removeShutdownHook(java.lang.Runnable task)
```
    Remove a previous added Runnable as a shutdown hook
  - runShutdownHooks
```
private boolean runShutdownHooks()
```
  - shutdown0
```
private void shutdown0(long quietPeriod,
                       long timeout,
                       int shutdownState)
```
  - 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()
  - 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 java.util.concurrent.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 java.util.concurrent.ExecutorService
  - isTerminated
```
public boolean isTerminated()
```
    Specified by:
    
    isTerminated in interface java.util.concurrent.ExecutorService
  - isSuspended
```
public boolean isSuspended()
```
    Description copied from interface: EventExecutor
    
    Returns true if the EventExecutor is considered suspended.
    
    Specified by:
    
    isSuspended in interface EventExecutor
    
    Returns:
    
    true if suspended, false otherwise.
  - trySuspend
```
public boolean trySuspend()
```
    Description copied from interface: EventExecutor
    Try to suspend this EventExecutor and return true if suspension was successful. Suspending an EventExecutor will allow it to free up resources, like for example a Thread that is backing the EventExecutor. Once an EventExecutor was suspended it will be started again by submitting work to it via one of the following methods:
    
    Executor.execute(Runnable)
    
    EventExecutorGroup.schedule(Runnable, long, TimeUnit)
    
    EventExecutorGroup.schedule(Callable, long, TimeUnit)
    
    EventExecutorGroup.scheduleAtFixedRate(Runnable, long, long, TimeUnit)
    
    EventExecutorGroup.scheduleWithFixedDelay(Runnable, long, long, TimeUnit)
    
    Even if this method returns true it might take some time for the EventExecutor to fully suspend itself.
    Specified by:
    
    trySuspend in interface EventExecutor
    
    Returns:
    
    true if suspension was successful, otherwise false.
  - canSuspend
```
protected boolean canSuspend()
```
    Returns true if this SingleThreadEventExecutor can be suspended at the moment, false otherwise.
    
    Returns:
    
    if suspension is possible at the moment.
  - canSuspend
```
protected boolean canSuspend(int state)
```
    Returns true if this SingleThreadEventExecutor can be suspended at the moment, false otherwise. Subclasses might override this method to add extra checks.
    
    Parameters:
    
    state - the current internal state of the SingleThreadEventExecutor.
    
    Returns:
    
    if suspension is possible at the moment.
  - confirmShutdown
```
protected boolean confirmShutdown()
```
    Confirm that the shutdown if the instance should be done now!
  - 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 task)
```
    Specified by:
    
    execute in interface java.util.concurrent.Executor
  - lazyExecute
```
public void lazyExecute(java.lang.Runnable task)
```
    Description copied from class: AbstractEventExecutor
    
    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.
    The default implementation just delegates to Executor.execute(Runnable).
    
    Overrides:
    
    lazyExecute in class AbstractEventExecutor
  - execute0
```
private void execute0(java.lang.Runnable task)
```
  - lazyExecute0
```
private void lazyExecute0(java.lang.Runnable task)
```
  - scheduleRemoveScheduled
```
void scheduleRemoveScheduled(ScheduledFutureTask<?> task)
```
    Overrides:
    
    scheduleRemoveScheduled in class AbstractScheduledEventExecutor
  - execute
```
private void execute(java.lang.Runnable task,
                     boolean immediate)
```
  - 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
  - throwIfInEventLoop
```
private void throwIfInEventLoop(java.lang.String method)
```
  - threadProperties
```
public final ThreadProperties threadProperties()
```
    Returns the ThreadProperties of the Thread that powers the SingleThreadEventExecutor. If the SingleThreadEventExecutor is not started yet, this operation will start it and block until it is fully started.
  - wakesUpForTask
```
protected boolean wakesUpForTask(java.lang.Runnable task)
```
    Can be overridden to control which tasks require waking the EventExecutor thread if it is waiting so that they can be run immediately.
  - reject
```
protected static void reject()
```
  - reject
```
protected final void reject(java.lang.Runnable task)
```
    Offers the task to the associated RejectedExecutionHandler.
    
    Parameters:
    
    task - to reject.
  - startThread
```
private void startThread()
```
  - ensureThreadStarted
```
private boolean ensureThreadStarted(int oldState)
```
  - doStartThread
```
private void doStartThread()
```
  - drainTasks
```
final int drainTasks()
```

Class SingleThreadEventExecutor

Nested Class Summary

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

Field Summary

Fields inherited from class io.netty.util.concurrent.AbstractScheduledEventExecutor

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

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

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

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

Methods inherited from interface java.lang.Iterable

Field Detail

DEFAULT_MAX_PENDING_EXECUTOR_TASKS

logger

ST_NOT_STARTED

ST_SUSPENDING

ST_SUSPENDED

ST_STARTED

ST_SHUTTING_DOWN

ST_SHUTDOWN

ST_TERMINATED

NOOP_TASK

STATE_UPDATER

PROPERTIES_UPDATER

ACCUMULATED_ACTIVE_TIME_NANOS_UPDATER

CONSECUTIVE_IDLE_CYCLES_UPDATER

CONSECUTIVE_BUSY_CYCLES_UPDATER

taskQueue

thread

threadProperties

executor

interrupted

processingLock

threadLock

shutdownHooks

addTaskWakesUp

maxPendingTasks

rejectedExecutionHandler

supportSuspension

accumulatedActiveTimeNanos

lastActivityTimeNanos

consecutiveIdleCycles

consecutiveBusyCycles

lastExecutionTime

state

gracefulShutdownQuietPeriod

gracefulShutdownTimeout

gracefulShutdownStartTime

terminationFuture

SCHEDULE_PURGE_INTERVAL

Constructor Detail

SingleThreadEventExecutor

SingleThreadEventExecutor

SingleThreadEventExecutor

SingleThreadEventExecutor

SingleThreadEventExecutor

SingleThreadEventExecutor

SingleThreadEventExecutor

SingleThreadEventExecutor

Method Detail

newTaskQueue

newTaskQueue

interruptThread

pollTask

pollTaskFrom

takeTask

fetchFromScheduledTaskQueue

executeExpiredScheduledTasks

peekTask

hasTasks

pendingTasks

addTask

offerTask

removeTask

runAllTasks

runScheduledAndExecutorTasks

runAllTasksFrom