CompletableFuture实际操作的源码追究

CompletableFuture实际操作的源码追究

在此之前整体框架：

• Completion：封装了执行任务，以及该任务所依赖的其他任务的结果，在执行任务时进行不同的操作。
• CompletableFuture：对任务结果的一些操作的封装，以及构建和处理Completion任务依赖的关系。

任务初始化：supplyAsync

    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
   
        return asyncSupplyStage(ASYNC_POOL, supplier);
    }

asyncSupplyStage方法

asyncSupplyStage方法会返回一个CompletableFuture供我们使用。

    static <U> CompletableFuture<U> asyncSupplyStage(Executor e,
                                                     Supplier<U> f) {
   
        if (f == null) throw new NullPointerException();
        CompletableFuture<U> d = new CompletableFuture<U>();
        e.execute(new AsyncSupply<U>(d, f));
        return d;
    }

其实就是创建了一个AsyncSupply交由线程池进行异步处理。这里的AsyncSupply是一个ForkJoinTask，也是一个Completion。

AsyncSupply类

    static final class AsyncSupply<T> extends ForkJoinTask<Void>
        implements Runnable, AsynchronousCompletionTask {
   
        CompletableFuture<T> dep; Supplier<? extends T> fn; // dep是本次任务的结果和有关依赖，fn是任务的执行逻辑
        AsyncSupply(CompletableFuture<T> dep, Supplier<? extends T> fn) {
   
            this.dep = dep; this.fn = fn;
        }

        public final Void getRawResult() {
    return null; }
        public final void setRawResult(Void v) {
   }
        public final boolean exec() {
    run(); return false; }

        public void run() {
   
            CompletableFuture<T> d; Supplier<? extends T> f;
            if ((d = dep) != null && (f = fn) != null) {
   
                dep = null; fn = null;
                if (d.result == null) {
   
                    try {
   
                        d.completeValue(f.get()); // <1>
                    } catch (Throwable ex) {
   
                        d.completeThrowable(ex);
                    }
                }
                d.postComplete();
            }
        }
    }

<1>执行任务fn.get，并将得到的结果封装到dep.result，result会作为一个任务是否被执行过或是否完成的状态的判断。

后续处理操作：thenAccept

// CompletableFuture#thenAccept
public CompletableFuture<Void