前文讲解了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内的任务是串行执行的，不管同步任务、还是异步任务都在排队在同一个栈里！所以其并不具备线程池这种能提高任务执行速度的能力的，它只是更方便的进行异步编程而已！一定要区分好！
