Netty Promise

Netty Promise

demo

package com.zc.demo.netty;

import io.netty.util.concurrent.*;

public class T01DefaultPromise {

    public static void main(String[] args) {
        // 构造线程池
        EventExecutor executor = new DefaultEventExecutor();

        // 创建 DefaultPromise 实例
        final Promise promise = new DefaultPromise(executor);

        // 下面给这个 promise 添加两个 listener
        promise.addListener(new GenericFutureListener<Future<Integer>>() {
            @Override
            public void operationComplete(Future future) throws Exception {
                if (future.isSuccess()) {
                    System.out.println("任务结束，结果：" + future.get());
                } else {
                    System.out.println("任务失败，异常：" + future.cause());
                }
            }
        }).addListener(new GenericFutureListener<Future<Integer>>() {
            @Override
            public void operationComplete(Future future) throws Exception {
                System.out.println("任务结束，balabala...");
            }
        });

        // 提交任务到线程池，1 秒后执行结束，设置执行 promise 的结果
        executor.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
                // 设置 promise 的结果
                // promise.setFailure(new RuntimeException());
                // 具体的任务不一定就要在这个 executor 中被执行。
                // 任务结束以后，需要调用 promise.setSuccess(result) 或失败 作为通知
                System.out.println("before promise.setSucess()");
                promise.setSuccess(123456);
            }
        });

        try {
            // main 线程阻塞等待执行结果
            promise.sync();
            System.out.println("main 线程从 promise.sync() 阻塞中返回");
        } catch (InterruptedException e) {

        }
    }
}

Promise 接口

Promise 接口继承自 Future 接口, 在 Future 基础上提供了设置处理结果的功能.

public interface Promise<V> extends Future<V> {

    /** 标记该 future 成功及设置其执行结果，并且会通知所有的 listeners
     */
    Promise<V> setSuccess(V result);

    /** 和 setSuccess 方法一样，只不过如果失败，它不抛异常，返回 false
     */
    boolean trySuccess(V result);

    /** 标记该 future 失败，及其失败原因. 失败会抛异常
     */
    Promise<V> setFailure(Throwable cause);

    /** 标记该 future 失败，及其失败原因. 不抛异常
     */
    boolean tryFailure(Throwable cause);

    /** 标记该 future 不可以被取消
     */
    boolean setUncancellable();
    // ...

}

DefaultPromise

DefaultPromise 通过 CAS 操作来进行更新执行结果的操作.

promise.setSuccess() 设置结果

通过 cas 操作设置 objResult, 设置成功后
调用 checkNotifyWaiters 判断 waiter 计数
执行 listener 的回调方法

@Override
public Promise<V> setSuccess(V result) {
    if (setSuccess0(result)) { // 对操作结果进行判断
        return this;
    }
    throw new IllegalStateException("complete already:" + this);
}

private boolean setSuccess0(V result) {
    return setValue0(result == null ? SUCCESS : result);
}

private static final AtomicReferenceFieldUpdater<DefaultPromise, Object> RESULT_UPDATER =
            AtomicReferenceFieldUpdater.newUpdater(DefaultPromise.class, Object.class, "result");// result 字段由使用 RESULT_UPDATER 更新

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 boolean setValue0(Object objResult) {
    if (RESULT_UPDATER.compareAndSet(this, null, objResult) ||
        RESULT_UPDATER.compareAndSet(this, UNCANCELLABLE, objResult)) { // 设置值
        if (checkNotifyWaiters()) {
            notifyListeners(); // 执行 listener 的回调方法
        }
        return true;
    }
    return false;
}

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();
        }
    });
}

AbstractFuture.get() 获取结果

根据 result 结果判断是否要等待.
若完成了, 则直接返回 promise,getNow() 从 promise 中取出设置的 result 并返回.
若未完成
    响应中断
    校验死锁
同步判断若未完成, 则增加 waiter 计数, wait() 等待, 唤醒后再减少 waiter 计数

future.get()

public V get() throws InterruptedException, ExecutionException { //
    await();// 阻塞直到异步操作完成, 当 I/O 操作完成后会被 notify()

    Throwable cause = cause();
    if (cause == null) {
        return getNow();// 成功则返回结果. 从 promise 中取出设置的 result 并返回
    }
    if (cause instanceof CancellationException) {// 由用户取消
        throw (CancellationException) cause;
    }
    throw new ExecutionException(cause);// 失败抛出异常
}

DefaultPromise.await()

public Promise<V> await() throws InterruptedException {
    if (isDone()) {
        return this;
    }

    if (Thread.interrupted()) { // 响应中断
        throw new InterruptedException(toString());
    }

    checkDeadLock();

    synchronized (this) {
        while (!isDone()) {
            incWaiters(); // 增加 waiter 计数
            try {
                wait(); // 等待
            } finally {
                decWaiters(); // 减少 waiter 计数
            }
        }
    }
    return this;
}

private static boolean isDone0(Object result) {
    return result != null && result != UNCANCELLABLE; // 结果不为 null 且 不为 UNCANCELLABLE
}