概述
promise 是可写的 future, 因为 future 不支持写操作接口，netty 使用 promise 扩展了 future, 可以对异步操作结果进行设置。
DefaultPromise 继承关系
Promise 接口定义
从接口定义可以看出，Promise 在 Future 接口的基础上扩展了，可写的接口。比如 setSuccess()、setFailure() 接口。还支持添加 listener，当执行完成 Promise 后自动回调添加的 listener，这样就不用再通过 get 阻塞的方式进行处理，提高执行效率。
DefaultPromise 成员变量
public class DefaultPromise<V> extends AbstractFuture<V> implements Promise<V> {
// 使用 CAS 进行更新执行结果 result 字段。
private static final AtomicReferenceFieldUpdater<DefaultPromise, Object> RESULT_UPDATER =
AtomicReferenceFieldUpdater.newUpdater(DefaultPromise.class, Object.class, "result");
// result 的几种 value
private static final Object SUCCESS = new Object();
private static final Object UNCANCELLABLE = new Object();
private static final CauseHolder CANCELLATION_CAUSE_HOLDER = new CauseHolder(ThrowableUtil.unknownStackTrace(
new CancellationException(), DefaultPromise.class, "cancel(...)"));
// 存储执行结果的变量
private volatile Object result;
// 执行的线程池
private final EventExecutor executor;
DefaultPromise 是通过 CAS 来进行更新执行的结果 result 字段的。
如果执行完成，无返回值则 result = SUCCESS。 有返回值则 result = 执行结果。
如果执行未完成，result = UNCANCELLABLE。
如果执行异常，result = CANCELLATION_CAUSE_HOLDER。
设置执行成功结果
@Override
public Promise<V> setSuccess(V result) {
if (setSuccess0(result)) {
notifyListeners();
return this;
}
throw new IllegalStateException("complete already: " + this);
}
1、调用 setSuccess0() 方法设置执行结果
2、如果设置成功则执行 所有通过addListener(GenericFutureListener<? extends Future<? super V>> listener)方法添加的 listener，并返回当前的 Promise。
3、执行失败抛出 IllegalStateException 异常
private boolean setSuccess0(V result) {
return setValue0(result == null ? SUCCESS : result);
}
private boolean setValue0(Object objResult) {
if (RESULT_UPDATER.compareAndSet(this, null, objResult) ||
RESULT_UPDATER.compareAndSet(this, UNCANCELLABLE, objResult)) {
checkNotifyWaiters();
return true;
}
return false;
}
private synchronized void checkNotifyWaiters() {
if (waiters > 0) {
notifyAll();
}
}
1、如果 result == null 则设置为 SUCCESS，然后调用 setValue0() 方法
2、通过 CAS 设置 DefaultPromise.result 值, 判断result 是否为 null 或者 UNCANCELLABLE，如果是则进行修改。如果不是说明已经执行完成（可能成功或失败）。然后调用checkNotifyWaiters() 方法进行唤醒所有 调用 DefaultPromise.get() 获取结果的线程。
3、根据 waiters 进行判断是否有需要唤醒的线程。每一次调用 get() 获取Promise执行结果的时候都会调用 incWaiters() 方法 ++waiters，执行完后调用 decWaiters() 进行 --waiters。
private void notifyListeners() {
EventExecutor executor = executor();
if (executor.inEventLoop()) {
final InternalThreadLocalMap threadLocals = InternalThreadLocalMap.get();
final int stackDepth = threadLocals.futureListenerStackDepth();
if (stackDepth < MAX_LISTENER_STACK_DEPTH) {
threadLocals.setFutureListenerStackDepth(stackDepth + 1);
try {
notifyListenersNow();
} finally {
threadLocals.setFutureListenerStackDepth(stackDepth);
}
return;
}
}
safeExecute(executor, new Runnable() {
@Override
public void run() {
notifyListenersNow();
}
});
}
获取 EventExecutor ，其实就是 EventLoop，判断执行 EventExecutor 的线程是否和当前线程一致，如果一致则调用 notifyListenersNow() 方法执行 listener。不一致则将任务封装成 Runnable 提交到任务队列中等待执行。
private void notifyListenersNow() {
Object listeners;
synchronized (this) {
// Only proceed if there are listeners to notify and we are not already notifying listeners.
if (notifyingListeners || this.listeners == null) {
return;
}
notifyingListeners = true;
listeners = this.listeners;
this.listeners = null;
}
for (;;) {
if (listeners instanceof DefaultFutureListeners) {
notifyListeners0((DefaultFutureListeners) listeners);
} else {
notifyListener0(this, (GenericFutureListener<?>) listeners);
}
synchronized (this) {
if (this.listeners == null) {
// Nothing can throw from within this method, so setting notifyingListeners back to false does not
// need to be in a finally block.
notifyingListeners = false;
return;
}
listeners = this.listeners;
this.listeners = null;
}
}
}
1、获取 listeners 值 并将 this.listeners 置为 null
listeners = this.listeners;
this.listeners = null;
2、调用 notifyListeners0() 或 notifyListener0() 方法执行 listeners
3、执行完 listeners 后，再次判断 this.listeners 是否为null，如果不为null，说明在执行过程中又有新的 listeners 添加进来，继续 for 循环执行。如果为 null 则return 退出 死循环。
private void notifyListeners0(DefaultFutureListeners listeners) {
GenericFutureListener<?>[] a = listeners.listeners();
int size = listeners.size();
for (int i = 0; i < size; i ++) {
notifyListener0(this, a[i]);
}
}
@SuppressWarnings({ "unchecked", "rawtypes" })
private static void notifyListener0(Future future, GenericFutureListener l) {
try {
l.operationComplete(future);
} catch (Throwable t) {
if (logger.isWarnEnabled()) {
logger.warn("An exception was thrown by " + l.getClass().getName() + ".operationComplete()", t);
}
}
}
执行添加的 listeners。
获取执行结果
@Override
public V get() throws InterruptedException, ExecutionException {
await();
Throwable cause = cause();
if (cause == null) {
return getNow();
}
if (cause instanceof CancellationException) {
throw (CancellationException) cause;
}
throw new ExecutionException(cause);
}
1、首先判断该 Promise 是否执行完成，如果执行完成则继续执行，如果没有执行完成则挂起当前线程。
2、判断执行是否有异常，如果没有异常则直接调用 getNow() 方法获取返回值。
3、如果有异常则首先判断异常是否是 CancellationException异常，如果是则直接抛出，不是则使用 ExecutionException 异常包装再抛出。
@Override
public Promise<V> await() throws InterruptedException {
if (isDone()) {
return this;
}
if (Thread.interrupted()) {
throw new InterruptedException(toString());
}
checkDeadLock();
synchronized (this) {
while (!isDone()) {
incWaiters();
try {
wait();
} finally {
decWaiters();
}
}
}
return this;
}
1、通过 isDone() 方法判断是否执行完成，如果执行完成直接返回
2、判断当前线程是否被中断，如果中断则直接抛出 InterruptedException 异常
3、检查执行 Promise 任务的线程是否是当前线程，如果是当前线程再调用 await() 就会发生死锁的情况，抛出 BlockingOperationException 异常。就相当于获取结果和执行都是当前线程，自己调用 await() 方法把自己阻塞掉了。
@SuppressWarnings("unchecked")
@Override
public V getNow() {
Object result = this.result;
if (result instanceof CauseHolder || result == SUCCESS || result == UNCANCELLABLE) {
return null;
}
return (V) result;
}
如果 Promise 执行无返回结果，当执行完成时会把 result 设置为 SUCCESS，这里判断如果有异常、SUCCESS 和 UNCANCELLABLE 则返回 null，否则返回执行结果 result。
