前文讲解了completablefuture的使用，本文将剖析其核心原理，前文连接：

【JAVA多线程】Future，专为异步编程而生_java future异步编程-CSDN博客

目录

1.任务组成任务链

2.默认使用ForkjoinPool作为线程池

3.任务是被串行执行的

---

1.任务组成任务链

completablefuture最核心的两个属性：

volatile Object result;//用来存放任务的执行结果
volatile Completion stack;//用来存放接下来要执行的任务

来看看Completion长什么样子：

不难发现，它是个runnable，而且内部还包含一个next指针，这种结构是能组成链表的：

2.默认使用ForkjoinPool作为线程池

completableFuture中创建同步/异步任务的时候是可以传参传一个线程池进去的，用来作为执行这个任务的线程池。但也可以不传，不传的时候completableFuture内部默认用的ForkJoinPool来执行任务：

private static final Executor asyncPool = useCommonPool ?
        ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();
        
public static CompletableFuture<Void> runAsync(Runnable runnable) {
    return asyncRunStage(asyncPool, runnable);
}

ForkJoinPool博主在上一篇文章里已经聊过了：

【JAVA多线程】ForkJoinPool，为高性能并行计算量身打造的线程池_forkjoinpool 并行度-CSDN博客

completableFuture之所以选ForkJoinPool来执行任务无非是看中了它的两个核心点：

• 工作窃取（线程间的负载均衡）

• fork join（自带对任务的同步、异步控制以保证结果的绝对正确）

ForkJoinPool.commonPool取到的是全局唯一的一个线程池，也就是说所有completableFuture的没有传参线程池的任务，用的都是同一个ForkJoinPool线程池，不同completableFuture的任务是可以并行执行的，所以ForkJoinPool的两个核心点能被完美利用起来。

3.任务是被串行执行的

可以看到不管是同步和异步都会进uniApplyStage这个方法，区别只是传参不同：

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

uniApplyStage这个方法：

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>();
        if (e != null || !d.uniApply(this, f, null)) {//thenApply会进uniApply
            UniApply<T,V> c = new UniApply<T,V>(e, d, this, f);
            push(c);//thenApplyAsync直接进栈
            c.tryFire(SYNC);
        }
        return d;
    }

thenApply会进uniApply会判断一下前置任务有没有完，完了的话直接执行它，没有完的话，就return false。

final <S> boolean uniApply(CompletableFuture<S> a,
                           Function<? super S,? extends T> f,
                           UniApply<S,T> c) {
    Object r; Throwable x;
    if (a == null || (r = a.result) == null || f == null)//判断前置任务有没有完
        return false;
    tryComplete: if (result == null) {
        if (r instanceof AltResult) {
            if ((x = ((AltResult)r).ex) != null) {
                completeThrowable(x, r);
                break tryComplete;
            }
            r = null;
        }
        try {
            if (c != null && !c.claim())
                return false;
            @SuppressWarnings("unchecked") S s = (S) r;
            completeValue(f.apply(s));//前置任务完了的话直接执行当前任务
        } catch (Throwable ex) {
            completeThrowable(ex);
        }
    }
    return true;
}

总结起来就是：

同步任务先尝试一下能不能执行，不能执行就进栈。异步任务直接进栈。

这个时候我们就发现了一个问题，completable中的任务一定是被串行执行的，比如下面这种链式调用，异步任务一定是排在同步任务之后执行的，不存在异步任务会和同步任务一起执行：

 CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("Fetching data...");
            try {
                Thread.sleep(2000); // 模拟耗时操作
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new IllegalStateException(e);
            }
            System.out.println("Data fetched.");
            return "Data from the network";
        }, executor)
        .thenApply(data -> {
            System.out.println("Parsing data...");
            String parsedData = parseData(data);
            System.out.println("Data parsed.");
            return parsedData;
        })
        .thenApplyAsync(parsedData -> {
            System.out.println("Saving data to database...");
            saveToDatabase(parsedData);
            System.out.println("Data saved.");
            return "Data processed.";
        }, executor);

这里我们也发现了一个关键点，也是Completable中很容易被混淆的一点：

complateFuture中的同步和异步只是执行线程的不同，异步并不能和当前任务在同一时间并驾齐驱的被执行，也是按顺序被执行的。

这就回到上文说的，为什么默认用ForkJoinPool去作为线程池，而且全局所有CompletableFuture都公用一个线程池，就是因为只有不同completableFuture的任务才会被并行执行，ForkJoinPool的工作窃取才有意义，同一个complateFuture每个时刻都只有一个任务在执行，没有并行执行的说法，用ForkJoinPool没任何意义。

所以我们要清楚的搞明白： CompletableFuture只是个同步/异步任务的编排工具类，为了保证任务执行顺序的绝对正确，同一个CompletableFuture内的任务是串行执行的，不管同步任务、还是异步任务都在排队在同一个栈里！所以其并不具备线程池这种能提高任务执行速度的能力的，它只是更方便的进行异步编程而已！一定要区分好！