DefaultPromise (Netty API Reference (4.1.22.Final))

java.lang.Object
- io.netty.util.concurrent.AbstractFuture<V>
- - io.netty.util.concurrent.DefaultPromise<V>

All Implemented Interfaces:

Promise <V>，java.util.concurrent.Future <V>

已知直接子类：

DefaultChannelPromise ， DefaultProgressivePromise
```
public class DefaultPromise<V>
extends AbstractFuture<V>
implements Promise<V>
```

构造方法摘要

构造方法
Modifier	Constructor and Description
`protected`	`DefaultPromise()` 执行人的期望见 `executor()` 。
	`DefaultPromise(EventExecutor executor)` 创建一个新的实例。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`Promise<V>`	`addListener(GenericFutureListener<? extends Future<? super V>> listener)` 将指定的侦听器添加到此将来。
`Promise<V>`	`addListeners(GenericFutureListener<? extends Future<? super V>>... listeners)` 将指定的侦听器添加到此将来。
`Promise<V>`	`await()` 等待这个未来的完成。
`boolean`	`await(long timeoutMillis)` 等待这个未来在规定的时限内完成。
`boolean`	`await(long timeout, java.util.concurrent.TimeUnit unit)` 等待这个未来在规定的时限内完成。
`Promise<V>`	`awaitUninterruptibly()` 等待这个未来不中断地完成。
`boolean`	`awaitUninterruptibly(long timeoutMillis)` 等待这个未来在规定的时间内完成而不会中断。
`boolean`	`awaitUninterruptibly(long timeout, java.util.concurrent.TimeUnit unit)` 等待这个未来在规定的时间内完成而不会中断。
`boolean`	`cancel(boolean mayInterruptIfRunning)` 如果取消成功，将会以 `CancellationException`失败。
`java.lang.Throwable`	`cause()` 如果I / O操作失败，则返回失败的I / O操作的原因。
`protected void`	`checkDeadLock()`
`protected EventExecutor`	`executor()` 当这个承诺完成时，让执行者用来通知监听者。
`V`	`getNow()` 无阻塞地返回结果。
`boolean`	`isCancellable()` 返回 `true`当且仅当该操作可通过取消 `Future.cancel(boolean)` 。
`boolean`	`isCancelled()`
`boolean`	`isDone()`
`boolean`	`isSuccess()` 当且仅当I / O操作成功完成时才返回 `true` 。
`protected static void`	`notifyListener(EventExecutor eventExecutor, Future<?> future, GenericFutureListener<?> listener)` 通知听众未来已完成。
`Promise<V>`	`removeListener(GenericFutureListener<? extends Future<? super V>> listener)` 从此将来删除指定侦听器的第一个匹配项。
`Promise<V>`	`removeListeners(GenericFutureListener<? extends Future<? super V>>... listeners)` 为将来的每个听众删除第一个匹配项。
`Promise<V>`	`setFailure(java.lang.Throwable cause)` 将这个未来标志为失败并通知所有听众。
`Promise<V>`	`setSuccess(V result)` 将这个未来标志为成功并通知所有听众。
`boolean`	`setUncancellable()` 使这个未来无法取消。
`Promise<V>`	`sync()` 等待这个未来，直到完成，并且在这个未来失败的时候重新引发失败的原因。
`Promise<V>`	`syncUninterruptibly()` 等待这个未来，直到完成，并且在这个未来失败的时候重新引发失败的原因。
`java.lang.String`	`toString()`
`protected java.lang.StringBuilder`	`toStringBuilder()`
`boolean`	`tryFailure(java.lang.Throwable cause)` 将这个未来标志为失败并通知所有听众。
`boolean`	`trySuccess(V result)` 将这个未来标志为成功并通知所有听众。

Methods inherited from class io.netty.util.concurrent.AbstractFuture
get, get

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.concurrent.Future
get, get

- 构造方法详细信息
  - DefaultPromise
```
public DefaultPromise(EventExecutor executor)
```
    创建一个新的实例。最好使用EventExecutor.newPromise()来创造新的承诺
    
    参数
    
    executor - EventExecutor用于在完成后通知承诺。假定这个执行者将防止StackOverflowError例外。如果堆栈深度超过阈值，执行程序可以通过执行Runnable来避免StackOverflowError 。
  - DefaultPromise
```
protected DefaultPromise()
```
    执行人的期望见 executor() 。
- 方法详细信息
  - setSuccess
```
public Promise<V> setSuccess(V result)
```
    从接口Promise复制的描述
    
    将这个未来标志为成功并通知所有听众。如果它已经成功或失败，它会抛出一个IllegalStateException 。
    
    Specified by:
    
    setSuccess ，界面 Promise<V>
  - trySuccess
```
public boolean trySuccess(V result)
```
    从界面复制的描述： Promise
    
    将这个未来标志为成功并通知所有听众。
    
    Specified by:
    
    trySuccess在界面 Promise<V>
    
    结果
    
    true当且仅当成功标记这个未来。否则false因为这个未来已经被标记为成功或失败。
  - setFailure
```
public Promise<V> setFailure(java.lang.Throwable cause)
```
    从接口复制的描述： Promise
    
    将这个未来标志为失败并通知所有听众。如果它已经成功或失败，它会抛出一个IllegalStateException 。
    
    Specified by:
    
    setFailure ，界面 Promise<V>
  - tryFailure
```
public boolean tryFailure(java.lang.Throwable cause)
```
    从界面复制而来的描述： Promise
    
    将这个未来标志为失败并通知所有听众。
    
    Specified by:
    
    tryFailure接口 Promise<V>
    
    结果
    
    true当且仅当成功将这个未来标记为失败。否则false因为这个未来已经被标记为成功或失败。
  - setUncancellable
```
public boolean setUncancellable()
```
    从接口复制的描述： Promise
    
    使这个未来无法取消。
    
    Specified by:
    
    setUncancellable接口 Promise<V>
    
    结果
    
    true当且仅当成功地将这个未来标记为不可撤销或已经完成而未被取消。 false如果这个未来已经被取消了。
  - isSuccess
```
public boolean isSuccess()
```
    从接口复制的描述： Future
    
    当且仅当I / O操作成功完成时返回 true 。
  - isCancellable
```
public boolean isCancellable()
```
    从界面复制的描述： Future
    
    返回 true当且仅当该操作可通过取消 Future.cancel(boolean) 。
  - cause
```
public java.lang.Throwable cause()
```
    从界面复制的描述： Future
    
    如果I / O操作失败，则返回失败的I / O操作的原因。
    
    结果
    
    失败的原因。 null如果成功或未来尚未完成。
  - addListener
```
public Promise<V> addListener(GenericFutureListener<? extends Future<? super V>> listener)
```
    从接口复制的描述： Future
    
    将指定的侦听器添加到此将来。当这个未来完成时，通知指定的监听器。如果这个未来已经完成，立即通知指定的监听器。
    
    Specified by:
    
    addListener ，界面 Promise<V>
  - addListeners
```
public Promise<V> addListeners(GenericFutureListener<? extends Future<? super V>>... listeners)
```
    从界面复制而来的描述： Future
    
    将指定的侦听器添加到此将来。这个未来完成时，通知指定的监听者。如果这个未来已经完成，则立即通知指定的监听者。
    
    Specified by:
    
    addListeners接口 Promise<V>
  - removeListener
```
public Promise<V> removeListener(GenericFutureListener<? extends Future<? super V>> listener)
```
    从界面复制的描述： Future
    
    从此将来删除指定侦听器的第一个匹配项。未来完成时，指定的监听器不再通知。如果指定的侦听器未与此将来关联，则此方法不执行任何操作并以静默方式返回。
    
    Specified by:
    
    removeListener ，界面 Promise<V>
  - removeListeners
```
public Promise<V> removeListeners(GenericFutureListener<? extends Future<? super V>>... listeners)
```
    从接口复制的描述： Future
    
    为将来的每个听众删除第一个匹配项。未来完成时，指定的监听器不再通知。如果指定的侦听器未与此将来关联，则此方法不执行任何操作并以静默方式返回。
    
    Specified by:
    
    removeListeners ，界面 Promise<V>
  - await
```
public Promise<V> await()
                 throws java.lang.InterruptedException
```
    从接口复制的描述： Future
    
    等待这个未来的完成。
    
    Specified by:
    
    await接口 Promise<V>
    
    异常
    
    java.lang.InterruptedException - 如果当前线程中断
  - awaitUninterruptibly
```
public Promise<V> awaitUninterruptibly()
```
    从界面复制的描述： Future
    
    等待这个未来不中断地完成。此方法捕获InterruptedException并以InterruptedException提示方式丢弃它。
    
    Specified by:
    
    awaitUninterruptibly接口 Promise<V>
  - await
```
public boolean await(long timeout,
                     java.util.concurrent.TimeUnit unit)
              throws java.lang.InterruptedException
```
    从接口复制的描述： Future
    
    等待这个未来在规定的时限内完成。
    
    结果
    
    当且仅当未来在指定的时间限制内完成时才会 true
    
    异常
    
    java.lang.InterruptedException - 如果当前线程中断
  - await
```
public boolean await(long timeoutMillis)
              throws java.lang.InterruptedException
```
    从接口复制的描述： Future
    
    等待这个未来在规定的时限内完成。
    
    结果
    
    true当且仅当未来是在规定的期限内完成
    
    异常
    
    java.lang.InterruptedException - 如果当前线程中断
  - awaitUninterruptibly
```
public boolean awaitUninterruptibly(long timeout,
                                    java.util.concurrent.TimeUnit unit)
```
    从接口复制的描述： Future
    
    等待这个未来在规定的时间内完成而不会中断。此方法捕获InterruptedException并以静默方式丢弃它。
    
    结果
    
    true当且仅当未来是在规定的期限内完成
  - awaitUninterruptibly
```
public boolean awaitUninterruptibly(long timeoutMillis)
```
    从界面复制的描述： Future
    
    等待这个未来在规定的时间内完成而不会中断。此方法捕获InterruptedException并以静默方式丢弃它。
    
    结果
    
    true当且仅当未来是在规定的期限内完成
  - getNow
```
public V getNow()
```
    从接口复制的描述： Future
    
    无阻塞地返回结果。如果未来还没有完成，这将返回null 。由于null值可能用于标记未来成功，因此您还需要检查未来是否真的用Future.isDone()完成，而不是在返回的null值上进行中继。
  - cancel
```
public boolean cancel(boolean mayInterruptIfRunning)
```
    如果取消成功，将会以 CancellationException失败。
    
    Specified by:
    
    cancel在界面 java.util.concurrent.Future<V>
    
    参数
    
    mayInterruptIfRunning - 此值在此实现中不起作用。
  - isCancelled
```
public boolean isCancelled()
```
    Specified by:
    
    isCancelled ，界面 java.util.concurrent.Future<V>
  - isDone
```
public boolean isDone()
```
    Specified by:
    
    isDone接口 java.util.concurrent.Future<V>
  - sync
```
public Promise<V> sync()
                throws java.lang.InterruptedException
```
    从界面复制而来的描述： Future
    
    等待这个未来，直到完成，并且在这个未来失败的时候重新引发失败的原因。
    
    Specified by:
    
    sync接口 Promise<V>
    
    异常
    
    java.lang.InterruptedException
  - syncUninterruptibly
```
public Promise<V> syncUninterruptibly()
```
    从界面复制的描述： Future
    
    等待这个未来，直到完成，并且在这个未来失败的时候重新引发失败的原因。
    
    Specified by:
    
    syncUninterruptibly接口 Promise<V>
  - toString
```
public java.lang.String toString()
```
    重写：
    
    toString在课堂 java.lang.Object
  - toStringBuilder
```
protected java.lang.StringBuilder toStringBuilder()
```
  - executor
```
protected EventExecutor executor()
```
    当这个承诺完成时，让执行者用来通知监听者。
    假定这个执行者将防止StackOverflowError例外。如果堆栈深度超过阈值，执行程序可以通过执行Runnable来避免StackOverflowError 。
    
    结果
    
    执行者用于在完成此承诺时通知监听者。
  - checkDeadLock
```
protected void checkDeadLock()
```
  - notifyListener
```
protected static void notifyListener(EventExecutor eventExecutor,
                                     Future<?> future,
                                     GenericFutureListener<?> listener)
```
    通知听众未来已完成。
    此方法的固定深度为MAX_LISTENER_STACK_DEPTH ，将限制递归以阻止StackOverflowError并且将在超过此阈值后停止通知侦听器。
    
    参数
    
    eventExecutor - 执行者用来通知聆听者 listener 。
    
    future - 完成的未来。
    
    listener - 听众通知。

Class DefaultPromise<V>

构造方法摘要

方法摘要

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

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.concurrent.Future

构造方法详细信息

DefaultPromise

DefaultPromise

方法详细信息

setSuccess

trySuccess

setFailure

tryFailure

setUncancellable

isSuccess

isCancellable

cause

addListener

addListeners

removeListener

removeListeners

await

awaitUninterruptibly

await

await

awaitUninterruptibly

awaitUninterruptibly

getNow

cancel

isCancelled

isDone

sync

syncUninterruptibly

toString

toStringBuilder

executor

checkDeadLock

notifyListener