public static void test() { CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> { String supplyAsyncResult = " "+Thread.currentThread().getName()+" Hello world! "; try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(supplyAsyncResult); return supplyAsyncResult; }).thenApplyAsync(r -> { //添加后续任务 String thenApplyResult = Thread.curentThread().getName()+r + " thenApply! "; System.out.println(thenApplyResult); return thenApplyResult; }); try { System.out.println(completableFuture.get() + " finish!"); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } } 打印：
ForkJoinPool.commonPool-worker-9 Hello world! ForkJoinPool.commonPool-worker-9 ForkJoinPool.commonPool-worker-9 Hello world! thenApply! ForkJoinPool.commonPool-worker-9 ForkJoinPool.commonPool-worker-9 Hello world! thenApply! finish! public void run() { CompletableFuture<T> d; Supplier<T> f; if ((d = dep) != null && (f = fn) != null) { dep = null; fn = null; //只是为了防止内存泄漏，方便 GC if (d.result == null) { try { d.completeValue(f.get()); //执行 task } catch (Throwable ex) { //执行 task 期间抛出了异常 d.completeThrowable(ex); } } d.postComplete(); } } 从源码上来看，supplyAsync 新起了一个线程，等到线程执行完 task，开始执行 d.postComplete(),即开始执行后续 task，然后 postComplete 会执行后续 task 的 completion 对象的 tryFire 方法。
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) { 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))//这里会发现前一个 stage 执行完毕，但提供了线程池 return null; dep = null; src = null; fn = null; return d.postFire(a, mode); } } 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())//会执行到这里，然后发现 claim 返回 false return false; @SuppressWarnings("unchecked") S s = (S) r; completeValue(f.apply(s)); } catch (Throwable ex) { completeThrowable(ex); } } return true; } final boolean claim() { Executor e = executor; if (compareAndSetForkJoinTaskTag((short)0, (short)1)) { if (e == null) return true; executor = null; // disable e.execute(this); //会执行到这里，然后把 this completion 对象提交给线程池执行，当前线程即将返回 } return false; } 我的问题在于，当 worker-9 线程执行完第一个 task 之后，它把第二个 task 提交给了 executor （e.execute(this)），然后线程就返回了（从 claim 函数一层一层返回，直到返回 postComplete ）。那为什么第二个 task 从打印结果来看，还是同一个 worker-9 线程来执行的？
还是说，只是因为我的例子比较简单，所以 executor 没有分配一个新的线程出来，其他情况下，thenApplyAsync 里面在执行e.execute(this)时，还是有可能新起一个线程的吗？
Select Language