SingleThreadEventExecutor (Netty API Reference (4.1.22.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 ，java.lang.Iterable < EventExecutor >，java.util.concurrent.Executor，java.util.concurrent.ExecutorService中，java.util.concurrent.ScheduledExecutorService

已知直接子类：

DefaultEventExecutor ， SingleThreadEventLoop
```
public abstract class SingleThreadEventExecutor
extends AbstractScheduledEventExecutor
implements OrderedEventExecutor
```
OrderedEventExecutor的抽象基类，它在单个线程中执行所有提交的任务。

构造方法摘要

构造方法
Modifier	Constructor and Description
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, java.util.concurrent.Executor executor, boolean addTaskWakesUp)` 创建一个新的实例
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, java.util.concurrent.Executor executor, boolean addTaskWakesUp, int maxPendingTasks, RejectedExecutionHandler rejectedHandler)` 创建一个新的实例
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, java.util.concurrent.ThreadFactory threadFactory, boolean addTaskWakesUp)` 创建一个新的实例
`protected`	`SingleThreadEventExecutor(EventExecutorGroup parent, java.util.concurrent.ThreadFactory threadFactory, boolean addTaskWakesUp, int maxPendingTasks, RejectedExecutionHandler rejectedHandler)` 创建一个新的实例

方法摘要

所有方法静态方法接口方法抽象方法具体的方法弃用的方法
Modifier and Type	Method and Description
`void`	`addShutdownHook(java.lang.Runnable task)` 添加一个 `Runnable`将在关闭此实例时执行
`protected void`	`addTask(java.lang.Runnable task)` 将任务添加到任务队列，或者在此之前关闭此实例时抛出 `RejectedExecutionException` 。
`protected void`	`afterRunningAllTasks()` 在从 `runAllTasks()`和 `runAllTasks(long)`返回之前调用。
`boolean`	`awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)`
`protected void`	`cleanup()` 无所作为，子类可能会覆盖
`protected boolean`	`confirmShutdown()` 确认实例应该立即关闭！
`protected long`	`delayNanos(long currentTimeNanos)` 返回执行最接近死线的计划任务之前剩余的时间量。
`void`	`execute(java.lang.Runnable task)`
`protected boolean`	`hasTasks()`
`boolean`	`inEventLoop(java.lang.Thread thread)` 返回 `true`如果给定 `Thread`在事件循环中执行， `false`其他。
`protected void`	`interruptThread()` 中断当前运行的 `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()` 返回`true`当且仅当所有`EventExecutor`由该被管小号`EventExecutorGroup`正在shut down gracefully或者被关闭。
`boolean`	`isTerminated()`
`protected java.util.Queue<java.lang.Runnable>`	`newTaskQueue()` 已过时。请使用并覆盖`newTaskQueue(int)` 。
`protected java.util.Queue<java.lang.Runnable>`	`newTaskQueue(int maxPendingTasks)` 创建一个新的 `Queue` ，它将保存要执行的任务。
`protected java.lang.Runnable`	`peekTask()`
`int`	`pendingTasks()` 返回待处理任务的数量。
`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)` 将任务提供给关联的`RejectedExecutionHandler` 。
`void`	`removeShutdownHook(java.lang.Runnable task)` 删除以前添加的 `Runnable`作为关机挂钩
`protected boolean`	`removeTask(java.lang.Runnable task)`
`protected abstract void`	`run()`
`protected boolean`	`runAllTasks()` 轮询任务队列中的所有任务，并通过 `Runnable.run()`方法运行它们。
`protected boolean`	`runAllTasks(long timeoutNanos)` 轮询任务队列中的所有任务，并通过 `Runnable.run()`方法运行它们。
`protected boolean`	`runAllTasksFrom(java.util.Queue<java.lang.Runnable> taskQueue)` 从传递的 `taskQueue`运行所有任务。
`void`	`shutdown()` 已过时。
`Future<?>`	`shutdownGracefully(long quietPeriod, long timeout, java.util.concurrent.TimeUnit unit)` 该执行者表示该调用者希望执行者被关闭。
`protected java.lang.Runnable`	`takeTask()` 从任务队列中取出下一个 `Runnable` ，如果当前没有任务存在，则会阻塞。
`Future<?>`	`terminationFuture()` 返回`Future`当所有被通知`EventExecutor`由该被管小号`EventExecutorGroup`已经终止。
`ThreadProperties`	`threadProperties()` 返回支持`SingleThreadEventExecutor`的`Thread`的`ThreadProperties` 。
`protected void`	`updateLastExecutionTime()` 更新内部时间戳，告知最近执行提交的任务的时间。
`protected boolean`	`wakesUpForTask(java.lang.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

- 构造方法详细信息
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                                    java.util.concurrent.ThreadFactory threadFactory,
                                    boolean addTaskWakesUp)
```
    创建一个新的实例
    
    参数
    
    parent - EventExecutorGroup这是此实例的父级，并且属于它
    
    threadFactory -在 ThreadFactory将被用于使用 Thread
    
    addTaskWakesUp - true当且仅当调用 addTask(Runnable)才会唤醒执行程序线程
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                                    java.util.concurrent.ThreadFactory threadFactory,
                                    boolean addTaskWakesUp,
                                    int maxPendingTasks,
                                    RejectedExecutionHandler rejectedHandler)
```
    创建一个新的实例
    
    参数
    
    parent - EventExecutorGroup ，它是此实例的父代并属于它
    
    threadFactory -在 ThreadFactory将被用于使用 Thread
    
    addTaskWakesUp - true当且仅当调用 addTask(Runnable)才会唤醒执行程序线程
    
    maxPendingTasks - 新任务将被拒绝之前的最大未决任务数。
    
    rejectedHandler - 使用RejectedExecutionHandler 。
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                                    java.util.concurrent.Executor executor,
                                    boolean addTaskWakesUp)
```
    创建一个新的实例
    
    参数
    
    parent - EventExecutorGroup这是此实例的父级，并且属于它
    
    executor - 将用于执行的 Executor
    
    addTaskWakesUp - true当且仅当调用 addTask(Runnable)才会唤醒执行程序线程
  - SingleThreadEventExecutor
```
protected SingleThreadEventExecutor(EventExecutorGroup parent,
                                    java.util.concurrent.Executor executor,
                                    boolean addTaskWakesUp,
                                    int maxPendingTasks,
                                    RejectedExecutionHandler rejectedHandler)
```
    创建一个新的实例
    
    参数
    
    parent - EventExecutorGroup ，它是此实例的父级，属于它
    
    executor - 将用于执行的 Executor
    
    addTaskWakesUp - true当且仅当调用 addTask(Runnable)才会唤醒执行程序线程
    
    maxPendingTasks - 新任务将被拒绝之前的最大未决任务数。
    
    rejectedHandler - 使用RejectedExecutionHandler 。
- 方法详细信息
  - newTaskQueue
```
@Deprecated
protected java.util.Queue<java.lang.Runnable> newTaskQueue()
```
    已过时。请使用并覆盖newTaskQueue(int) 。
  - newTaskQueue
```
protected java.util.Queue<java.lang.Runnable> newTaskQueue(int maxPendingTasks)
```
    创建一个新的Queue ，它将保存要执行的任务。此默认实现将返回LinkedBlockingQueue ，但如果你的子类SingleThreadEventExecutor不会做的这所有的阻塞调用Queue它可能是有意义的@Override这一点，并返回一些更高性能的实现，它完全不支持阻塞操作。
  - interruptThread
```
protected void interruptThread()
```
    中断当前运行的 Thread 。
  - pollTask
```
protected java.lang.Runnable pollTask()
```
    另请参见：
    
    Queue.poll()
  - pollTaskFrom
```
protected static java.lang.Runnable pollTaskFrom(java.util.Queue<java.lang.Runnable> taskQueue)
```
  - takeTask
```
protected java.lang.Runnable takeTask()
```
    从任务队列中Runnable一个Runnable ，如果当前没有任务存在，将会阻塞。
    请注意，此方法将抛出一个UnsupportedOperationException如果任务队列，这是通过创建newTaskQueue() ，没有实现BlockingQueue 。
    
    结果
    
    null如果执行程序线程被中断或唤醒。
  - peekTask
```
protected java.lang.Runnable peekTask()
```
    另请参见：
    
    Queue.peek()
  - hasTasks
```
protected boolean hasTasks()
```
    另请参见：
    
    Collection.isEmpty()
  - pendingTasks
```
public int pendingTasks()
```
    返回待处理任务的数量。 请注意，此操作可能很昂贵，因为它取决于SingleThreadEventExecutor的内部实现。 所以使用它很在乎！
  - addTask
```
protected void addTask(java.lang.Runnable task)
```
    将任务添加到任务队列，或者在此之前关闭此实例时抛出 RejectedExecutionException 。
  - removeTask
```
protected boolean removeTask(java.lang.Runnable task)
```
    另请参见：
    
    Collection.remove(Object)
  - runAllTasks
```
protected boolean runAllTasks()
```
    轮询任务队列中的所有任务，并通过 Runnable.run()方法运行它们。
    
    结果
    
    true当且仅当至少有一个任务运行
  - runAllTasksFrom
```
protected final boolean runAllTasksFrom(java.util.Queue<java.lang.Runnable> taskQueue)
```
    从传递的 taskQueue运行所有任务。
    
    参数
    
    taskQueue - 轮询和执行所有任务。
    
    结果
    
    如果至少执行了一项任务， true 。
  - runAllTasks
```
protected boolean runAllTasks(long timeoutNanos)
```
    轮询任务队列中的所有任务，并通过Runnable.run()方法运行它们。此方法停止运行任务队列中的任务，并在其运行时间超过timeoutNanos返回。
  - afterRunningAllTasks
```
@UnstableApi
protected void afterRunningAllTasks()
```
    在从 runAllTasks()和 runAllTasks(long)返回之前调用。
  - delayNanos
```
protected long delayNanos(long currentTimeNanos)
```
    返回执行最接近死线的计划任务之前剩余的时间量。
  - updateLastExecutionTime
```
protected void updateLastExecutionTime()
```
    更新内部时间戳，告知最近执行提交的任务的时间。 runAllTasks()和runAllTasks(long)自动更新此时间戳，因此通常不需要调用此方法。但是，如果使用takeTask()或pollTask()手动执行任务，则必须在任务执行循环结束时调用此方法以进行精确的静默期检查。
  - run
```
protected abstract void run()
```
  - cleanup
```
protected void cleanup()
```
    无所作为，子类可能会覆盖
  - wakeup
```
protected void wakeup(boolean inEventLoop)
```
  - inEventLoop
```
public boolean inEventLoop(java.lang.Thread thread)
```
    从界面复制的描述： EventExecutor
    
    返回 true如果给定 Thread在事件循环中执行， false其他。
    
    Specified by:
    
    inEventLoop ，界面 EventExecutor
  - addShutdownHook
```
public void addShutdownHook(java.lang.Runnable task)
```
    添加一个 Runnable ，将在关闭此实例时执行
  - removeShutdownHook
```
public void removeShutdownHook(java.lang.Runnable task)
```
    删除以前添加的 Runnable作为关机挂钩
  - shutdownGracefully
```
public Future<?> shutdownGracefully(long quietPeriod,
                                    long timeout,
                                    java.util.concurrent.TimeUnit unit)
```
    从界面： EventExecutorGroup复制的描述
    
    该执行者表示该调用者希望执行者被关闭。一旦调用此方法， EventExecutorGroup.isShuttingDown()开始返回true ，执行程序准备自行关闭。与EventExecutorGroup.shutdown()不同，正常关机可确保在关闭之前不会提交“安静期” （通常是几秒钟）的任务。如果任务在安静期提交，则保证被接受，安静期将重新开始。
    
    Specified by:
    
    shutdownGracefully ，界面 EventExecutorGroup
    
    参数
    
    quietPeriod - 文档中描述的安静期
    
    timeout - 不管在静默期间是否提交任务，等待执行程序为 EventExecutorGroup.shutdown()的最长时间
    
    unit - quietPeriod和 timeout的单位
    
    结果
    
    EventExecutorGroup.terminationFuture()
  - terminationFuture
```
public Future<?> terminationFuture()
```
    从界面复制而来的描述： EventExecutorGroup
    
    返回Future当所有被通知EventExecutor由该被管小号EventExecutorGroup已经终止。
    
    Specified by:
    
    terminationFuture在界面 EventExecutorGroup
  - shutdown
```
@Deprecated
public void shutdown()
```
    已过时。
    
    Specified by:
    
    shutdown接口 EventExecutorGroup
    
    Specified by:
    
    shutdown在界面 java.util.concurrent.ExecutorService
    
    Specified by:
    
    shutdown在课堂 AbstractEventExecutor
  - isShuttingDown
```
public boolean isShuttingDown()
```
    从界面： EventExecutorGroup复制的描述
    
    返回true当且仅当所有EventExecutor由该被管小号EventExecutorGroup正在shut down gracefully或者被关闭。
    
    Specified by:
    
    isShuttingDown ，界面 EventExecutorGroup
  - isShutdown
```
public boolean isShutdown()
```
    Specified by:
    
    isShutdown ，界面 java.util.concurrent.ExecutorService
  - isTerminated
```
public boolean isTerminated()
```
    Specified by:
    
    isTerminated ，界面 java.util.concurrent.ExecutorService
  - confirmShutdown
```
protected boolean confirmShutdown()
```
    确认实例应该立即关闭！
  - awaitTermination
```
public boolean awaitTermination(long timeout,
                                java.util.concurrent.TimeUnit unit)
                         throws java.lang.InterruptedException
```
    Specified by:
    
    awaitTermination接口 java.util.concurrent.ExecutorService
    
    异常
    
    java.lang.InterruptedException
  - execute
```
public void execute(java.lang.Runnable task)
```
    Specified by:
    
    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
```
    Specified by:
    
    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
```
    Specified by:
    
    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
```
    Specified by:
    
    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
```
    Specified by:
    
    invokeAll ，界面 java.util.concurrent.ExecutorService
    
    重写：
    
    invokeAll在课堂 java.util.concurrent.AbstractExecutorService
    
    异常
    
    java.lang.InterruptedException
  - threadProperties
```
public final ThreadProperties threadProperties()
```
    返回支持SingleThreadEventExecutor的Thread的ThreadProperties 。如果SingleThreadEventExecutor尚未启动，此操作将启动它并阻塞，直到它完全启动。
  - wakesUpForTask
```
protected boolean wakesUpForTask(java.lang.Runnable task)
```
  - reject
```
protected static void reject()
```
  - reject
```
protected final void reject(java.lang.Runnable task)
```
    将任务提供给关联的RejectedExecutionHandler 。
    
    参数
    
    task - 拒绝。

Class SingleThreadEventExecutor

构造方法摘要

方法摘要

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

构造方法详细信息

SingleThreadEventExecutor

SingleThreadEventExecutor

SingleThreadEventExecutor

SingleThreadEventExecutor

方法详细信息

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