CompletableFuture理解实现原理

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Supplier;


public class MyFuture {

    Object result;

    // 当前future执行完成之后 执行, 一个head, 形成的一个链表
    Completion stack;

   // function bifunction consumer supplier 会有各自的实现
    public static class Completion implements Runnable {

        // 执行线程池
        Executor e;
        // 上一个future 主要作用用来判定上一个是否有结果了, 如果是thenCombine 就要多一个, 因为有2个异步执行
        MyFuture src;

        // 当前Stage关联的future, 其主要作用是Future自身关联的Completion, 当当前Stage执行完成, 继续执行关联的Stage
        MyFuture dep;

        // function consumer supplier... 具体的执行方法
        Object runnable;

        // 关联的下一个, 主要用在Future遍历
        /*
            Future f = Future.supplyAsync();
            f.thenAccept();
            f.thenAccept();
         */
        Completion next;

        // src 上一个future, 主要作用用来判定上一个是否有结果了,
        // 例如 src.result == null,
        public Completion(MyFuture dep, MyFuture src, Object runnable) {
            this.dep = dep;
            this.runnable = runnable;
//            this.e = e,
            this.src = src;
        }

        @Override
        public void run() {
            // 同步执行
            // do runnable
            // 执行完成, 调用Future关联的所有Stage
            dep.postComplete();
        }

        /**
         * 用来切线程
         */
        boolean claim() {
            if (e == null) {
                return true;
            }
            Executor e1 = e;
            // 这里把e set成null是为了当后续再执行到这里就不会重新提交到线程了, 这样claim就不会再拦截了
            e = null;

            e1.execute(this);

            return false;
        }

//       tryFire 抽象方法, 用来适配不同的stage, 比如是个apply, runnable, consumer
        // 只是尝试执行, 如果要执行还要判断依赖的上一个结果是否完成
        void tryFire() {
            // 如果是consumer, 调用consumer的方法..
            // 假定我这里是一个consumer,
            // completion里关联了一个completableFuture
            dep.uniAccept(src, null, this);

            // 如果是BiApply, 则调用的是
//            dep.biApply(src, src1, null, this);
        }
    }

    private void postComplete() {
        Completion c = stack;
        while (c != null) {
            c.tryFire();
            c = c.next;
        }
    }


    void pushStack(Completion c) {
        if (stack == null) {
            stack = c;
            return;
        }
        Completion c1 = stack;
        while (c1.next != null) {
            c1 = c1.next;
        }
        c1.next = c;
    }


    /**
     *
     * @param src 上一个future
     * @param consumer 可以直接执行的consumer
     * @param completion 包装了consumer的completion 最大的作用是可以切线程, 有个方法是claim, 拦截调consumer的直接执行
     */
    private void uniAccept(MyFuture src, Consumer<?> consumer, Completion completion) {
        // 因为依赖的上一个future没有执行完成, 无法执行
        if (src.result == null) {
            return;
        }

        // 如果切了线程这里就直接返回了
        if (!completion.claim()) {
            return;
        }

        // 执行的就是上一个future的执行结果
//        consumer.accept(src.result);
    }


    public static MyFuture supplyAsync(Supplier<?> s) {
        final MyFuture myFuture = new MyFuture();
        // 开始操作, 异步执行, 直接放线程池里
        Executors.newSingleThreadExecutor().execute(() -> new Completion(myFuture, null, s));
        return myFuture;
    }


    public MyFuture thenAccept(Consumer<?> s) {
        final MyFuture myFuture = new MyFuture();
        final Completion completion = new Completion(myFuture, this, s);
        // 当前future的stack串
        pushStack(completion);
        return myFuture;
    }


    // 协调多个线程并合并结果
    public MyFuture thenCombine(MyFuture future, BiFunction f) {
        final MyFuture myFuture = new MyFuture();
        // 创建Completion的时候就需要2个future
//        final Completion completion = new Completion(myFuture, future, this, f);
        // 当前future的stack串
//        pushStack(completion);
		// 同时还要push到 otherFuture 的stack里
        // pushStack(otherFuture, completion)
        return myFuture;
    }

    /**
     * 最终执行函数
     * @param src 上一个future
     * @param function 可以直接执行的function
     * @param completion 包装了consumer的completion 最大的作用是可以切线程, 有个方法是claim, 拦截调consumer的直接执行
     */
    private void biApply(MyFuture src, MyFuture src1, BiFunction<?, ?, ?> function, Completion completion) {
        // 因为依赖的上一个future没有执行完成, 无法执行
        if (src.result == null || src1.result == null) {
            return;
        }

        // 如果切了线程这里就直接返回了, claim 提交了线程池
        if (!completion.claim()) {
            return;
        }

        // 这个就是在当前线程执行
        // 执行的就是上一个future的执行结果
//        function.apply(src.result, src1.result);
    }

    public static void main(String[] args) {

        MyFuture.supplyAsync(() -> 10)
            .thenAccept(c -> {})
                .thenAccept(v -> { });

    }

}

最主要的操作是每个Completion 关联一个/多个Future, Future又关联了一个Completion链表这样一直关联下去, 上一个/多个future的完成触发关联的Completion