SingleThreadEventExecutor (Netty 4.0.56.Final API文档

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

所有已实现的接口:

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

直接已知子类:

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.

构造器概要

构造器
限定符	构造器和说明
`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, int maxPendingTasks, RejectedExecutionHandler rejectedHandler)` Create a new instance

方法概要

方法
限定符和类型	方法和说明
`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.
`boolean`	`awaitTermination(long timeout, java.util.concurrent.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(java.lang.Runnable task)`
`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 this executor was started to be shut down gracefuclly or was shut down.
`boolean`	`isTerminated()`
`protected java.util.Queue<java.lang.Runnable>`	`newTaskQueue()` 已过时。 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.
`EventExecutorGroup`	`parent()` Return the `EventExecutorGroup` which is the parent of this `EventExecutor`,
`protected java.lang.Runnable`	`peekTask()`
`int`	`pendingTasks()` Return the number of tasks that are pending for processing.
`protected java.lang.Runnable`	`pollTask()`
`protected static void`	`reject()`
`void`	`removeShutdownHook(java.lang.Runnable task)` Remove a previous added `Runnable` as a shutdown hook
`protected boolean`	`removeTask(java.lang.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.
`void`	`shutdown()` 已过时。
`Future<?>`	`shutdownGracefully(long quietPeriod, long timeout, java.util.concurrent.TimeUnit unit)` Signals this executor that the caller wants the executor to be shut down.
`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 this executor has 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(java.lang.Runnable task)`
`protected void`	`wakeup(boolean inEventLoop)`

从类继承的方法 io.netty.util.concurrent.AbstractScheduledEventExecutor
cancelScheduledTasks, hasScheduledTasks, nanoTime, nextScheduledTaskNano, pollScheduledTask, pollScheduledTask, schedule, schedule, scheduleAtFixedRate, scheduleWithFixedDelay

从类继承的方法 io.netty.util.concurrent.AbstractEventExecutor
inEventLoop, iterator, newFailedFuture, newProgressivePromise, newPromise, newSucceededFuture, newTaskFor, newTaskFor, next, shutdownGracefully, shutdownNow, submit, submit, submit

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从接口继承的方法 io.netty.util.concurrent.EventExecutor
inEventLoop, newFailedFuture, newProgressivePromise, newPromise, newSucceededFuture, next

从接口继承的方法 io.netty.util.concurrent.EventExecutorGroup
iterator, schedule, schedule, scheduleAtFixedRate, scheduleWithFixedDelay, shutdownGracefully, shutdownNow, submit, submit, submit

- 构造器详细资料
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                         java.util.concurrent.ThreadFactory threadFactory,
                         boolean addTaskWakesUp)
```
    Create a new instance
    
    参数:
    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
    
    参数:
    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.
- 方法详细资料
  - newTaskQueue
```
@Deprecated
protected java.util.Queue<java.lang.Runnable> newTaskQueue()
```
    已过时。 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.
  - parent
```
public EventExecutorGroup parent()
```
    从接口复制的说明: EventExecutor
    
    Return the EventExecutorGroup which is the parent of this EventExecutor,
    
    指定者:
    
    parent 在接口中 EventExecutor
  - interruptThread
```
protected void interruptThread()
```
    Interrupt the current running Thread.
  - pollTask
```
protected java.lang.Runnable pollTask()
```
    另请参阅:
    Queue.poll()
  - 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.
    
    返回:
    null if the executor thread has been interrupted or waken up.
  - peekTask
```
protected java.lang.Runnable peekTask()
```
    另请参阅:
    Queue.peek()
  - hasTasks
```
protected boolean hasTasks()
```
    另请参阅:
    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(java.lang.Runnable task)
```
    Add a task to the task queue, or throws a RejectedExecutionException if this instance was shutdown before.
  - removeTask
```
protected boolean removeTask(java.lang.Runnable task)
```
    另请参阅:
    Collection.remove(Object)
  - runAllTasks
```
protected boolean runAllTasks()
```
    Poll all tasks from the task queue and run them via Runnable.run() method.
    
    返回:
    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(java.lang.Thread thread)
```
    从接口复制的说明: EventExecutor
    
    Return true if the given Thread is executed in the event loop, false otherwise.
    
    指定者:
    
    inEventLoop 在接口中 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
  - shutdownGracefully
```
public Future<?> shutdownGracefully(long quietPeriod,
                           long timeout,
                           java.util.concurrent.TimeUnit unit)
```
    从接口复制的说明: 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.
    
    指定者:
    
    shutdownGracefully 在接口中 EventExecutorGroup
    
    参数:
    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
    
    返回:
    the EventExecutorGroup.terminationFuture()
  - terminationFuture
```
public Future<?> terminationFuture()
```
    从接口复制的说明: EventExecutorGroup
    
    Returns the Future which is notified when this executor has been terminated.
    
    指定者:
    
    terminationFuture 在接口中 EventExecutorGroup
  - shutdown
```
@Deprecated
public void shutdown()
```
    已过时。
    
    指定者:
    
    shutdown 在接口中 EventExecutorGroup
    
    指定者:
    
    shutdown 在接口中 java.util.concurrent.ExecutorService
    
    指定者:
    
    shutdown 在类中 AbstractEventExecutor
  - isShuttingDown
```
public boolean isShuttingDown()
```
    从接口复制的说明: EventExecutorGroup
    
    Returns true if and only if this executor was started to be shut down gracefuclly or was shut down.
    
    指定者:
    
    isShuttingDown 在接口中 EventExecutorGroup
  - isShutdown
```
public boolean isShutdown()
```
    指定者:
    
    isShutdown 在接口中 java.util.concurrent.ExecutorService
  - isTerminated
```
public boolean isTerminated()
```
    指定者:
    
    isTerminated 在接口中 java.util.concurrent.ExecutorService
  - 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
```
    指定者:
    
    awaitTermination 在接口中 java.util.concurrent.ExecutorService
    
    抛出:
    
    java.lang.InterruptedException
  - execute
```
public void execute(java.lang.Runnable task)
```
    指定者:
    
    execute 在接口中 java.util.concurrent.Executor
  - invokeAny
```
public <T> T invokeAny(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks)
            throws java.lang.InterruptedException,
                   java.util.concurrent.ExecutionException
```
    指定者:
    
    invokeAny 在接口中 java.util.concurrent.ExecutorService
    
    覆盖:
    
    invokeAny 在类中 java.util.concurrent.AbstractExecutorService
    
    抛出:
    
    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
```
    指定者:
    
    invokeAny 在接口中 java.util.concurrent.ExecutorService
    
    覆盖:
    
    invokeAny 在类中 java.util.concurrent.AbstractExecutorService
    
    抛出:
    
    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
```
    指定者:
    
    invokeAll 在接口中 java.util.concurrent.ExecutorService
    
    覆盖:
    
    invokeAll 在类中 java.util.concurrent.AbstractExecutorService
    
    抛出:
    
    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
```
    指定者:
    
    invokeAll 在接口中 java.util.concurrent.ExecutorService
    
    覆盖:
    
    invokeAll 在类中 java.util.concurrent.AbstractExecutorService
    
    抛出:
    
    java.lang.InterruptedException
  - threadProperties
```
public final ThreadProperties threadProperties()
```
    Returns the ThreadProperties of the Thread that powers the SingleThreadEventExecutor.
  - wakesUpForTask
```
protected boolean wakesUpForTask(java.lang.Runnable task)
```
  - reject
```
protected static void reject()
```

类 SingleThreadEventExecutor

构造器概要

方法概要

从类继承的方法 io.netty.util.concurrent.AbstractScheduledEventExecutor

从类继承的方法 io.netty.util.concurrent.AbstractEventExecutor

从类继承的方法 java.lang.Object

从接口继承的方法 io.netty.util.concurrent.EventExecutor

从接口继承的方法 io.netty.util.concurrent.EventExecutorGroup

构造器详细资料

SingleThreadEventExecutor

SingleThreadEventExecutor

方法详细资料

newTaskQueue

newTaskQueue

parent

interruptThread

pollTask

takeTask

peekTask

hasTasks

pendingTasks

addTask

removeTask

runAllTasks

runAllTasks

delayNanos

updateLastExecutionTime

run

cleanup

wakeup

inEventLoop

addShutdownHook

removeShutdownHook

shutdownGracefully

terminationFuture

shutdown

isShuttingDown

isShutdown

isTerminated

confirmShutdown

awaitTermination

execute

invokeAny

invokeAny

invokeAll

invokeAll

threadProperties

wakesUpForTask

reject