前文讲解了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来执行任务：
java">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这个方法，区别只是传参不同：
java">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这个方法：
java">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会进uniApplyUniApply<T,V> c = new UniApply<T,V>(e, d, this, f);push(c);//thenApplyAsync直接进栈c.tryFire(SYNC);}return d;}thenApply会进uniApply会判断一下前置任务有没有完，完了的话直接执行它，没有完的话，就return false。
java">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中的任务一定是被串行执行的，比如下面这种链式调用，异步任务一定是排在同步任务之后执行的，不存在异步任务会和同步任务一起执行：
java"> 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内的任务是串行执行的，不管同步任务、还是异步任务都在排队在同一个栈里！所以其并不具备线程池这种能提高任务执行速度的能力的，它只是更方便的进行异步编程而已！一定要区分好！
