CompletableFuture 源码浅要阅读

completablefuture 的使用相当便捷，不过它的方法初次学习起来也相当困难，简单的阅读一下它的实现原理可能会让我们更好的掌握这个类的使用。不过它的源码读起来也和它的使用一样，相当抽象。。。异常抽象

注释

进入代码发现它的注释就有老长一段，以下是比较有用的部分：

• CompletableFuture 是一个在完成时可以触发相关方法和操作的 Future，并且它可以视作为 CompletableStage
• CompletableFuture 的取消会被视为异常完成。调用 cancel 方法会和调用 completeExceptionally 方法具有同样的效果
• 如果没有显示指定的 Executor 的参数，则会调用默认的ForkJoinPool.commonPool()，最好使用指定的线程池，由于守护线程的原因使用默认线程池的话会出现一些奇妙的bug

它实现了 Future 以及 CompletionStage

public class CompletableFuture<T> implements Future<T>, CompletionStage<T>

创建一个 CompletableFuture

众所周知，创建一个CompletableFuture可以使用run组和supply组的方法，那么这两者创建的CompletableFuture有什么不同呢

supplyAsync的源码：

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

	//逻辑运行的主要方法
    static <U> CompletableFuture<U> asyncSupplyStage(Executor e,
                                                     Supplier<U> f) {
        if (f == null) throw new NullPointerException();
        //new一个新的CompletableFuture
        CompletableFuture<U> d = new CompletableFuture<U>();
        //进入线程池
        e.execute(new AsyncSupply<U>(d, f));
        //返回CompletableFuture，异步
        return d;
    }

我们看到进入线程池的是一个AsyncSupply对象，里面包含了这个新创建的CompletableFuture以及我们重写的supplier

同时看到CompletableFuture直接返回，标志了这是一个异步任务，可以猜测与同步实现的区别就在这

runAsync的源码：

    static CompletableFuture<Void> asyncRunStage(Executor e, Runnable f) {
        if (f == null) throw new NullPointerException();
        CompletableFuture<Void> d = new CompletableFuture<Void>();
        e.execute(new AsyncRun(d, f));
        return d;
    }

看到两者没什么不同，都是条件判断加丢进线程池。区别在于这次丢进去的是AsyncRun

事实上其他的几个创建CompletableFuture的方法都类似这样，也可以猜测AsyncRun的实现与AsyncSupply大差不差

AsyncSupply类

AsyncSupply是completablefuture的内部类，这是它的所有源码：

    static final class AsyncSupply<T> extends ForkJoinTask<Void>
            implements Runnable, AsynchronousCompletionTask {
        CompletableFuture<T> dep; Supplier<T> fn;
        AsyncSupply(CompletableFuture<T> dep, Supplier<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 true; }

        public void run() {
            CompletableFuture<T> d; Supplier<T> f;
            if ((d = dep) != null && (f = fn) != null) {
                dep = null; fn = null;
                //传入的是一个new CompletableFuture，它所包含的值为null才正常
                if (d.result == null) {
                    try {
                        d.completeValue(f.get());
                    } catch (Throwable ex) {
                        d.completeThrowable(ex);
                    }
                }
                d.postComplete();
            }
        }
    }

奇怪的地方

等等等等，你们发现了一个奇怪的地方吗

        CompletableFuture<T> dep; Supplier<T> fn;
        AsyncSupply(CompletableFuture<T> dep, Supplier<T> fn) {
            this.dep = dep; this.fn = fn;
        }
        ...
        public void run() {
            CompletableFuture<T> d; Supplier<T> f;
            if ((d = dep) != null && (f = fn) != null)
            ...

为什么要定义两次CompletableFuture以及Supplier呢，这么做有什么好处吗？

我的猜测是这样的：dep与fn是在堆中指向堆中的对象引用，而d与f是存放在run方法中局部变量表的引用。首先，它执行多线程任务的时候不会因为指针的变幻而出错，其次这么写可以避免一次查找对象的过程，让运行速度变快

d.completeValue(f.get())语句

该方法使用UNSAFE类的CAS操作，将supplier结果设置给completablefuture的RESULT

    final boolean completeValue(T t) {
        return UNSAFE.compareAndSwapObject(this, RESULT, null,
                                           (t == null) ? NIL : t);
    }

那completeThrowable一定就是异常的处理了

    final boolean completeThrowable(Throwable x) {
        return UNSAFE.compareAndSwapObject(this, RESULT, null,
                                           encodeThrowable(x));
    }

在了解d.postComplete()之前，需要先看看CompletableFuture的结构，上面已经讲过，它实现了Future以及CompletionStage，那CompletionStage是什么

CompletionStage

官方定义中，一个Function，Comsumer或者Runnable都可以被描述为一个CompletionStage

CompletionStage是一个可能执行异步计算的“阶段”，这个阶段会在另一个CompletionStage完成时调用去执行动作或者计算，一个CompletionStage会以正常完成或者中断的形式“完成”，并且它的“完成”会触发其他依赖的CompletionStage。CompletionStage 接口的方法一般都返回新的CompletionStage，因此构成了链式的调用

public interface CompletionStage<T> {

    public <U> CompletionStage<U> thenApply(Function<? super T,? extends U> fn);

    public <U> CompletionStage<U> thenApplyAsync
        (Function<? super T,? extends U> fn);
	...

可以看到，CompletableFuture的所有后续操作都在CompletionStage中被定义

选择一个简单的后续操作，看看在CompletableFuture中的实现

    public <U> CompletableFuture<U> thenApply(
        Function<? super T,? extends U> fn) {
        return uniApplyStage(null, fn);
    }

    private <V> CompletableFuture<V> uniApplyStage(
        Executor e, Function<? super T,? extends V> f) {
        //异常判断
        if (f == null) throw new NullPointerException();
        CompletableFuture<V> d =  new CompletableFuture<V>();
        //条件判断，线程池是否为null以及CompletableFuture是否已经运行
        if (e != null || !d.uniApply(this, f, null)) {
            UniApply<T,V> c = new UniApply<T,V>(e, d, this, f);
            //放进栈中
            push(c);
            c.tryFire(SYNC);
        }
        return d;
    }

此方法就是判断当前CompletableFuture是否已经运行，如果没运行，将新创建的CompletableFuture、执行该方法的CompletableFuture、线程池、我们重写的Function打包成一个UniApply，并且放入这个CompletableFuture的栈中

那么这个栈是个什么东西，这个UniAccept又是什么？

UniAccept

该类的构造方法就是简单的赋值

    static final class UniApply<T,V> extends UniCompletion<T,V> {
        Function<? super T,? extends V> fn;
        UniApply(Executor executor, CompletableFuture<V> dep,
                 CompletableFuture<T> src,
                 Function<? super T,? extends V> fn) {
            // dep: 新创建的CompletableFuture
  			// src: 驱动thenAccept的CompletableFuture
            super(executor, dep, src); this.fn = fn;
        }
        
        final CompletableFuture<V> tryFire(int mode) {
            CompletableFuture<V> d; CompletableFuture<T> a;
            if ((d = dep) == null ||
                !d.uniApply(a = src, fn, mode > 0 ? null : this))
                return null;
            dep = null; src = null; fn = null;
            return d.postFire(a, mode);
        }
    }

可以看到它的构造方法调用了它的父类方法，那它的父类是什么？

Completion

abstract static class Completion extends ForkJoinTask<Void>
        implements Runnable, AsynchronousCompletionTask {
        volatile Completion next;      
        abstract CompletableFuture<?> tryFire(int mode);
        abstract boolean isLive();

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

Completion是一个抽象类，分别实现了Runnable、AsynchronousCompletionTask接口，继承了ForkJoinPoolTask类，而ForJoinPoolTask抽象类又实现了Future接口，因此Completion可以简单的看成一个Future

我们看到Completion类中有一个next，说明它是一个链表结构

而之前那个问题，栈是什么，栈就是CompletableFuture中的一个属性stack，而这个stack就是Completion类的

这里面的一个方法tryFire，就是尝试启动下一个Completion的意思

总结

以上，我们简单过了一遍CompletableFuture的创建以及后续操作的实现

• CompletableFuture的创建是使用CAS操作将我们的传入的方法以及最后的实现参数赋值给CompletableFuture中的属性
• CompletableFuture中对于各个组的实现大同小异
• 后续操作是从postComplete方法中引出来的，后续操作定义在CompletionStage接口中，后续操作的实现是通过Compition类的链表结构实现的
• 每次调用后续操作方法都会生成一个新的CompletableFuture