SingleThreadEventExecutor (Netty API Reference (4.1.11.Final))

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, Iterable<EventExecutor>, Executor, ExecutorService, 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.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor, boolean addTaskWakesUp)` Create a new instance
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor, boolean addTaskWakesUp, int maxPendingTasks, RejectedExecutionHandler rejectedHandler)` Create a new instance
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, ThreadFactory threadFactory, boolean addTaskWakesUp)` Create a new instance
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, 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 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.
`protected void`	`afterRunningAllTasks()` Invoked before returning from `runAllTasks()` and `runAllTasks(long)`.
`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`.
`<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`	`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`	`isTerminated()`
`protected Queue<Runnable>`	`newTaskQueue()` Deprecated. Please use and override `newTaskQueue(int)`.
`protected Queue<Runnable>`	`newTaskQueue(int maxPendingTasks)` Create a new `Queue` which will holds the tasks to execute.
`protected Runnable`	`peekTask()`
`int`	`pendingTasks()` Return the number of tasks that are pending for processing.
`protected Runnable`	`pollTask()`
`protected static Runnable`	`pollTaskFrom(Queue<Runnable> taskQueue)`
`protected static void`	`reject()`
`protected void`	`reject(Runnable task)` Offers the task to the associated `RejectedExecutionHandler`.
`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.
`protected boolean`	`runAllTasksFrom(Queue<Runnable> taskQueue)` Runs all tasks from the passed `taskQueue`.
`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 all `EventExecutor`s managed by this `EventExecutorGroup` have been terminated.
`ThreadProperties`	`threadProperties()` Returns the `ThreadProperties` of the `Thread` that powers the `SingleThreadEventExecutor`.
`protected void`	`updateLastExecutionTime()` Updates the internal timestamp that tells when a submitted task was executed most recently.
`protected boolean`	`wakesUpForTask(Runnable task)`
`protected void`	`wakeup(boolean inEventLoop)`

Methods inherited from class io.netty.util.concurrent.AbstractScheduledEventExecutor
cancelScheduledTasks, hasScheduledTasks, nanoTime, nextScheduledTaskNano, pollScheduledTask, pollScheduledTask, schedule, schedule, scheduleAtFixedRate, scheduleWithFixedDelay

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

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
  - 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
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                                    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,
                                    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,
                                    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.
- Method Detail
  - newTaskQueue
```
@Deprecated
protected Queue<Runnable> newTaskQueue()
```
    Deprecated. Please use and override newTaskQueue(int).
  - newTaskQueue
```
protected Queue<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 Runnable pollTask()
```
    See Also:
    
    Queue.poll()
  - pollTaskFrom
```
protected static Runnable pollTaskFrom(Queue<Runnable> taskQueue)
```
  - 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:
    
    Collection.isEmpty()
  - pendingTasks
```
public 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:
    
    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
  - runAllTasksFrom
```
protected final boolean runAllTasksFrom(Queue<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.
  - 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
```
@UnstableApi
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.
  - 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.
    
    Specified by:
    
    inEventLoop in interface EventExecutor
  - 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.
    
    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
  - 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
```
    Specified by:
    
    awaitTermination in interface ExecutorService
    
    Throws:
    
    InterruptedException
  - execute
```
public void execute(Runnable task)
```
    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
  - 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 the it is fully started.
  - wakesUpForTask
```
protected boolean wakesUpForTask(Runnable task)
```
  - reject
```
protected static void reject()
```
  - reject
```
protected final void reject(Runnable task)
```
    Offers the task to the associated RejectedExecutionHandler.
    
    Parameters:
    
    task - to reject.

Class SingleThreadEventExecutor

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

Constructor Detail

SingleThreadEventExecutor

SingleThreadEventExecutor

SingleThreadEventExecutor

SingleThreadEventExecutor

Method Detail

newTaskQueue

newTaskQueue

interruptThread

pollTask

pollTaskFrom

takeTask

peekTask

hasTasks

pendingTasks

addTask

removeTask

runAllTasks

runAllTasksFrom

runAllTasks

afterRunningAllTasks

delayNanos

updateLastExecutionTime

run

cleanup

wakeup

inEventLoop

addShutdownHook

removeShutdownHook

shutdownGracefully

terminationFuture

shutdown

isShuttingDown

isShutdown

isTerminated

confirmShutdown

awaitTermination

execute

invokeAny

invokeAny

invokeAll

invokeAll

threadProperties

wakesUpForTask

reject

reject