禅与计算机
sharkchili
2026-03-25
目录

CompletableFuture基础实践小结

[toc]

# 写在文章开头

CompletableFuture继承了CompletionStage接口和Future接口，在原有Future的基础上增加了异步回调、流式处理以及任务组合，成为JDK8多任务协同场景下一个有效利器。所以笔者今天就以此文演示一下CompletableFuture基础实践案例。

Hi，我是 sharkChili ，是个不断在硬核技术上作死的技术人，是 CSDN的博客专家 ，也是开源项目 Java Guide 的维护者之一，熟悉 Java 也会一点 Go ，偶尔也会在 C源码 边缘徘徊。写过很多有意思的技术博客，也还在研究并输出技术的路上，希望我的文章对你有帮助，非常欢迎你关注我的公众号： 写代码的SharkChili 。

同时也非常欢迎你star我的开源项目mini-redis:https://github.com/shark-ctrl/mini-redis (opens new window)

因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注 “加群” 即可和笔者和笔者的朋友们进行深入交流。

# 详解CompletableFuture的设计理念和使用

# CompletableFuture基本设计

因为本文着重讲解CompletableFuture的使用，所以这里我们就简单的从类的继承关系了解一下CompletableFuture的基本理念，结合CompletableFuture源码注释的说法，它是一个针对异步流程化的工具类，即它支持某个异步Future任务完成之后按照指定编排的顺序触发下一个依赖动作：

A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage, supporting dependent functions and actions that trigger upon its completion. When two or more threads attempt to complete, completeExceptionally, or cancel a CompletableFuture, only one of them succeeds.

举个例子，例如我现在在浏览器上某个网站的商家的产品，我希望浏览器能够做到以下几点：

  1. 我针对性点选择3个商家。
  2. 3个门店在我勾选点击查看信息后，分别开始查询各自的产品数据。
  3. 3家数据都完成数据加载后，网站归并这些数据，通过一个网页渲染给我查看。

通过CompletableFuture，我们就可以完成通过CompletableFuture将上述商家的查询任务进行异步提交：

对此我们也可以从CompletableFuture的继承关系了解其设计理念：

  1. 它继承Future接口使之具备阻塞获取异步回调的能力。
  2. 继承CompletionStage接口，它永远thenApply等方法，通过这个继承关系，使CompletableFuture具备异步任务顺序编排的能力，即当前异步任务一处理完成就执行thenApply给定的异步逻辑，使得我们可以清晰明了的编排异步任务：
public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
	//......
}
1
2
3

# 提交有返回值的异步任务

通过supplyAsync提交我们的异步任务，然后通过get方法等待异步任务完成并获取返回结果。

public static void main(String[] args) throws Exception {
        //提交一个CompletableFuture任务
        CompletableFuture<Integer> task = CompletableFuture.supplyAsync(() -> {
            long start = System.currentTimeMillis();

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("work complete! cost:" +(System.currentTimeMillis() - start)  + " ms");
            return 1;
        });


        System.out.println("main thread working");

        //通过get方法阻塞获取任务执行结果
        System.out.println("supplyAsync result： " + task.get());

        System.out.println("main thread finish");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

输出结果如下，可以看出CompletableFuture的get方法会阻塞主线程工作，直到得到返回值为止。

main thread working
work complete! cost:1001 ms
supplyAsync result： 1
main thread finish
1
2
3
4

对此我们不妨来看看get方法是如何做到阻塞主线程并等待异步线程任务执行完成的。从下面这段源码我们可以看到get方法的执行步骤:

  1. 调用reportGet查看异步任务是否将结果赋值给result。
  2. 如果不为null直接返回。
  3. 若为null则调用waitingGet等待任务返回。
public T get() throws InterruptedException, ExecutionException {
        Object r;
        return reportGet((r = result) == null ? waitingGet(true) : r);
    }
1
2
3
4

查看reportGet方法可以看到逻辑也很简单，如果r为空则直接抛中断异常，如果r存在异常则直接将异常抛出，如果有结果则将结果返回。

  private static <T> T reportGet(Object r)
        throws InterruptedException, ExecutionException {
        //如果结果为null直接抛出终端异常
        if (r == null) // by convention below, null means interrupted
            throw new InterruptedException();
         //如果结果有异常则将异常抛出
        if (r instanceof AltResult) {
            Throwable x, cause;
            if ((x = ((AltResult)r).ex) == null)
                return null;
            if (x instanceof CancellationException)
                throw (CancellationException)x;
            if ((x instanceof CompletionException) &&
                (cause = x.getCause()) != null)
                x = cause;
            throw new ExecutionException(x);
        }
        //如果r正常则直接将结果返回出去
        @SuppressWarnings("unchecked") T t = (T) r;
        return t;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

waitingGet源码相对复杂一些，整体步骤我们可以拆解为while循环内部和while循环外部,我们先来看看while循环内部的执行流程:

  1. while循环从任务中获取result，如果result为空，则进入循环。
  2. 如果spins小于0，说明刚刚进入循环内部，可以自旋等待一下任务的获取，设置好spins(spins的值从SPINS来，如果多核的情况下值为256)，进入下一次循环。
  3. 进入循环发现spins大于0,则随机生成一个数，如果这个数大于等于0则--spins，进入下次循环。
  4. 不断执行步骤3的操作，知道spins等于0。
  5. 此时判断来到q==null,说明任务自旋等待了一段时间还是没有结果，我们需要将其挂起，首先将线程封装成一个Signaller，进入下一次循环。
  6. 循环会判断if (!queued)，将要阻塞的任务放到栈中，进入下一次循环。
  7. 循环下一次会来到if (q.thread != null && result == null)，说明q线程不为空且没有结果，我们需要将其打断，调用ForkJoinPool.managedBlock(q)将其打断，直至有结果后才结束循环。

while循环外操作就简单了，来到循环尾部时，result已经有值了，代码执行postComplete完成任务，并将结果返回。

private Object waitingGet(boolean interruptible) {
        Signaller q = null;
        boolean queued = false;
        int spins = -1;
        Object r;
        //如果result为空则进入循环
        while ((r = result) == null) {
        //如果spins小于0，说明刚刚进入循环内部，可以自旋等待一下任务的获取，设置好spins(spins的值从SPINS来，如果多核的情况下值为256)，自此，第一次循环步骤结束
            if (spins < 0)
                spins = SPINS;

			//这一步的操作是自旋等待任务结果，所以代码进入循环发现spins大于0,则随机生成一个数，如果这个数大于等于0则--spins，进入下次循环,直到循环spins变为0
            else if (spins > 0) {
                if (ThreadLocalRandom.nextSecondarySeed() >= 0)
                    --spins;
            }
            //此时判断来到q==null,说明任务自旋等待了一段时间还是没有结果，我们需要将其挂起，首先将线程封装成一个Signaller，结束本次循环
            else if (q == null)
                q = new Signaller(interruptible, 0L, 0L);
			//上一步我们将任务封装成Signaller，这里就将其存入栈中，然后结束循环
            else if (!queued)
                queued = tryPushStack(q);
            else if (interruptible && q.interruptControl < 0) {
                q.thread = null;
                cleanStack();
                return null;
            }
            //循环来到这说明q线程不为空且没有结果，我们需要将其打断，调用`ForkJoinPool.managedBlock(q)`将其打断，直至有结果后才结束循环
            else if (q.thread != null && result == null) {
                try {
                    ForkJoinPool.managedBlock(q);
                } catch (InterruptedException ie) {
                    q.interruptControl = -1;
                }
            }
        }
        if (q != null) {
            q.thread = null;
            if (q.interruptControl < 0) {
                if (interruptible)
                    r = null; // report interruption
                else
                    Thread.currentThread().interrupt();
            }
        }
        //结束循环，调用postComplete结束任务并返回结果r
        postComplete();
        return r;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

# 提交无返回值的异步任务

通过runAsync提交一个无返回值的异步任务，这里我们为了实现任务执行完成再关闭主线程用了个get阻塞等待任务完成。

public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Void> supplyAsync = CompletableFuture.runAsync(() -> {
            long start = System.currentTimeMillis();
            System.out.println(Thread.currentThread().getName() + "开始工作了，执行时间：" + start);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "结束工作了，总执行时间：" + (System.currentTimeMillis() - start));
        });

        System.out.println("主线程开始运行");
        //get阻塞主线程等待任务结束
        supplyAsync.get();
        System.out.println("主线程运行结束");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果

主线程开始运行
ForkJoinPool.commonPool-worker-1开始工作了，执行时间：1651251489755
ForkJoinPool.commonPool-worker-1结束工作了，总执行时间：1010
主线程运行结束
1
2
3
4

# 将异步任务提交给自己的线程池处理

查看supplyAsync方法的源码我们发现，我们提交的任务默认情况下会交给asyncPool这个线程池处理。

 public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
        return asyncSupplyStage(asyncPool, supplier);
    }
1
2
3

查看asyncPool 我们可以看到如果服务器是多核的情况下返回的是一个commonPool，commonPool默认线程池数为CPU核心数。

 private static final Executor asyncPool = useCommonPool ?
        ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();
1
2

所以如果某些情况下我们希望将任务提交到我们自己的线程池中，就建议通过supplyAsync的第二个参数告知CompletableFuture自己要用自定义线程池。

public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        //使用第二个参数告知CompletableFuture使用的线程池
        CompletableFuture<Integer> supplyAsync = CompletableFuture.supplyAsync(() -> {
            long start = System.currentTimeMillis();
            System.out.println(Thread.currentThread() + "开始工作了，执行时间：" + start);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //打印当前执行任务的线程
            System.out.println(Thread.currentThread() + "结束工作了，总执行时间：" + (System.currentTimeMillis() - start));
            return 1;
        }, executorService);

        System.out.println("主线程开始运行");
        System.out.println("输出结果 " + supplyAsync.get());
        System.out.println("主线程运行结束");

        executorService.shutdown();
        while (executorService.isTerminated()) {

        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

从输出结果也可以看出这里使用的线程池是我们自定义的线程池

主线程开始运行
Thread[pool-1-thread-1,5,main]开始工作了，执行时间：1651251851358
Thread[pool-1-thread-1,5,main]结束工作了，总执行时间：2005
输出结果 1
主线程运行结束
1
2
3
4
5
6

# thenApply和thenApplyAsync

thenApply 适用那些需要顺序执行的异步任务，例如我们希望将第一个任务的返回值交给第二个异步任务，就可以使用thenApply将两个任务组合起来。

public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        CompletableFuture<Integer> task1 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread() + "开始工作了");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread() + "结束工作了");
            return 100;
        }, executorService);

        //将两个任务组合起来
        CompletableFuture<String> task2 = task1.thenApply((data) -> {
            System.out.println("第二个线程：" + Thread.currentThread() + "开始工作了");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "第一个线程的结果为 " + data;
        });



        System.out.println("获取组合任务结果");
        System.out.println("组合任务处理结果为: " + task2.get());
        System.out.println("获取组合任务结果结束");

        executorService.shutdown();
        while (executorService.isTerminated()) {

        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

输出结果可以看到，任务1执行完成后任务2接着执行了。

Thread[pool-1-thread-1,5,main]开始工作了
获取组合任务结果
Thread[pool-1-thread-1,5,main]结束工作了
第二个线程：Thread[pool-1-thread-1,5,main]开始工作了
组合任务处理结果为: 第一个线程的结果为 100
获取组合任务结果结束
1
2
3
4
5
6

thenApplyAsync与thenApply不同的是，在第一个异步任务有指定线程池的情况下，第二个异步任务会被提交到其他线程池中，所以这里我们可以说明一个规律，带有Async关键字的方法支持组合任务时，将任务提交到不同的线程池中。

public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        CompletableFuture<Integer> task1 = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread()+"开始工作了");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread()+"结束工作了");
            return 100;
        },executorService);

        CompletableFuture<String> task2 = task1.thenApplyAsync((data) -> {
            System.out.println("第二个线程：" + Thread.currentThread() + "开始工作了");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "第一个线程的结果为 " + data;
        });



        System.out.println("获取任务结果开始");
        System.out.println("任务的结果 "+task2.get());
        System.out.println("获取任务结果结束");

        executorService.shutdown();
        while (executorService.isTerminated()){

        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

输出结果

Thread[pool-1-thread-1,5,main]开始工作了
获取任务结果开始
Thread[pool-1-thread-1,5,main]结束工作了
第二个线程：Thread[ForkJoinPool.commonPool-worker-9,5,main]开始工作了
任务的结果 第一个线程的结果为 100
获取任务结果结束
1
2
3
4
5
6

# thenAccept和thenRun

thenAccept和thenRun都会在上一个任务执行结束后才会继续执行。两者唯一区别时:

  1. thenAccept在上一个任务执行结束后，将上一个任务返回结果作为入参，但无返回值。

  1. thenRun会在上一个任务执行结束后才开始处理，既没有入参也没有返回值。

以下便是笔者的使用示例:

public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(5);


        CompletableFuture<Integer> task = CompletableFuture.supplyAsync(() -> {
            System.out.println("task线程:" + Thread.currentThread().getName() + "开始工作了");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("task线程:" + Thread.currentThread().getName() + "结束工作了");
            return 200;
        }, executorService);

        CompletableFuture<Integer> task2 = task.thenApply((data) -> {
            System.out.println("task2线程：" + Thread.currentThread().getName() + "开始工作了");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("task2线程：" + Thread.currentThread().getName() + "执行结束");
            return data;
        });

        //thenAccept 收上一个任务的入参，但无返回值
        CompletableFuture<Void> task3 = task2.thenAccept((data) -> {
            System.out.println("task3线程:" + Thread.currentThread().getName() + "，该任务接收上一个任务的结果，但无返回值，收到上一个任务的结果值为 " + data);
        });

        //thenRun在上一个任务结束后执行，既无入参也无出参
        CompletableFuture<Void> task4 = task3.thenRun(() -> {
            System.out.println("task4在上一个任务结束后继续执行，无入参,也无返回值");
        });


        System.out.println("尝试获取最终执行结果");
        task4.get();
        System.out.println("执行任务直至task4 ");
        System.out.println("任务全部执行结束");

        executorService.shutdown();
        while (executorService.isTerminated()) {

        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

输出结果

task线程:pool-1-thread-1开始工作了
尝试获取最终执行结果
task线程:pool-1-thread-1结束工作了
task2线程：pool-1-thread-1开始工作了
task2线程：pool-1-thread-1执行结束
task3线程:pool-1-thread-1，该任务接收上一个任务的结果，但无返回值，收到上一个任务的结果值为 200
task4在上一个任务结束后继续执行，无入参,也无返回值
执行任务直至task4 
任务全部执行结束
1
2
3
4
5
6
7
8
9
10

# exceptionally

假如我们的任务1执行过程中可能报错，我们希望能够从逻辑的角度处理掉，那么我们就可以在任务1后面接一个exceptionally方法，然后再接上任务2。这样一来，任务1执行报错就会走到exceptionally，反之就会走到任务2的代码段：

public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> task1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("task1 开始工作了");
            //随机生成被除数，为0会抛出算术异常
            int num = RandomUtil.randomInt(0, 2);
            int result = 10 / num;
            System.out.println("task1 结束工作");
            return 200;
        });

        //假如task1报错，任务会走到这个任务上
        CompletableFuture<Integer> exceptionally = task1.exceptionally((e) -> {
            System.out.println("上一个任务报错了，错误信息" + e.getMessage());
            return -1;
        });

        CompletableFuture task2 = task1.thenAccept((param) -> {
            System.out.println("走到正常的结束分支了，task1执行结果:" + param);
        });

        System.out.println("主线程开始运行");
//        调用错误捕获的任务执行结束也会自动走到正常结束的分支
        System.out.println("输出结果 " + exceptionally.get());
        System.out.println("主线程运行结束");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

执行正常的输出结果:

task1 开始工作了
主线程开始运行
task1 结束工作
走到正常的结束分支了:200
输出结果 200
主线程运行结束
1
2
3
4
5
6
7

执行异常的输出结果:

task1 开始工作了
主线程开始运行
上一个任务报错了，错误信息java.lang.ArithmeticException: / by zero
输出结果 -1
主线程运行结束
1
2
3
4
5

# whenComplete

对于上面的例子，我们完全可以用whenComplete来简化，whenComplete会接收两个入参:

  1. 入参1为上一个任务的返回值。
  2. 入参2比较特殊，如果上一个任务抛出异常，则第2个入参不为空。

所以上一个例子的代码我们可以简化成这样,需要注意的是whenComplete返回结果是上一个任务的执行结果，我们无法返回任务2的执行结果。

 public static void main(String[] args) {

        CompletableFuture<Integer> task = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1开始工作");
            int num = RandomUtil.randomInt(0, 2);
            int result = 10 / num;
            System.out.println("任务1执行结束，执行结果:" + result);
            return result;
        });

        CompletableFuture<Integer> task2 = task.whenComplete((result, err) -> {
            System.out.println("任务2开始工作");

            if (err != null) {
                System.out.println("任务1执行报错，报错原因:" + err.getMessage());
                return;
            }

            System.out.println("任务1正常结束，执行结果:" + result);

        });


        try {
            System.out.println("task2拿到最终执行结果 " + task2.get());
        } catch (Exception e) {

        }
        System.out.println("全流程结束");


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

错误的输出结果

任务1开始工作
任务2开始工作
任务1执行报错，报错原因:java.lang.ArithmeticException: / by zero
全流程结束
1
2
3
4

正确执行的输出结果:

任务1开始工作
任务1执行结束，执行结果:10
任务2开始工作
任务1正常结束，执行结果:10
task2拿到最终执行结果 10
全流程结束
1
2
3
4
5
6

# handle

handle使用和whenComplete差不多，唯一的区别就是whenComplete返回的是上一个任务的结果，而handle可以返回自己的结果。

代码如下所示

public static void execute1() throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread() + "开始工作了");
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            Random random = new java.util.Random();
            int num = random.nextInt(10);
            if (num < 5) {
                throw new RuntimeException("报错了 num:" + num);
            }
            System.out.println(Thread.currentThread() + "结束工作了");
            return num;
        });

        CompletableFuture<String> future2 = future.handle((result, err) -> {
            System.out.println("第二个线程：" + Thread.currentThread() + "开始工作了");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (err != null) {
                System.out.println(err.getMessage());
                ;return "fail";
            }
            return "sucdess";
        });


        System.out.println("拿第1个任务的结果");
        System.out.println("第1个任务的结果 " + future2.get());
        System.out.println("第1个任务结果结束");



        /**
         * 输出结果
         * Thread[pool-1-thread-1,5,main]开始工作了
         * 拿第一个任务的结果
         * Thread[pool-1-thread-1,5,main]结束工作了
         * 第二个线程：Thread[pool-1-thread-1,5,main]开始工作了
         * 100
         * 第一个任务结果结束
         * 拿第2个任务的结果
         * 第二个任务的结果 第一个线程的结果为 100
         * 第2个任务结果结束
         */

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

# thenCombine / thenAcceptBoth / runAfterBoth

这几个方法都是将两个任务组合起来执行的，只有两个任务都顺利完成了，才会执行之后的方法，唯一的区别是:

  1. thenCombine 接收两个任务的返回值，并返回自己的返回值。
public static void main(String[] args) throws ExecutionException, InterruptedException {

        CompletableFuture<Integer> task1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("task开始工作");
            int num = RandomUtil.randomInt(0, 100);
            System.out.println("task结束工作");
            return num;
        });


        CompletableFuture<Integer> task2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("task2开始工作");
            int num = RandomUtil.randomInt(0, 100);
            System.out.println("task2结束工作");
            return num;
        });

        //通过thenCombine将两个任务组合起来
        CompletableFuture<Integer> completableFuture = task1.thenCombine(task2, (result1, result2) -> {
            System.out.println("task1返回结果:" + result1 + "  task2返回结果:" + result2);
            return result1 + result2;
        });


        System.out.println(completableFuture.get());


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

输出结果如下:

task开始工作
task2开始工作
task结束工作
task2结束工作
task1返回结果:30  task2返回结果:1
31
1
2
3
4
5
6
  1. thenAcceptBoth 接收两个参数返回值，但没有返回值。
public static void main(String[] args) throws ExecutionException, InterruptedException {

        CompletableFuture<Integer> task1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("task开始工作");
            int num = RandomUtil.randomInt(0, 100);
            System.out.println("task结束工作");
            return num;
        });


        CompletableFuture<Integer> task2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("task2开始工作");
            int num = RandomUtil.randomInt(0, 100);
            System.out.println("task2结束工作");
            return num;
        });

        //通过 thenAcceptBoth 将两个任务组合起来,获取前两个任务处理结果，但自己不返回结果
        CompletableFuture<Void> completableFuture = task1.thenAcceptBoth(task2, (result1, result2) -> {
            System.out.println("task1返回结果:" + result1 + "  task2返回结果:" + result2);

        });


        completableFuture.get();


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

输出结果:

task开始工作
task2开始工作
task结束工作
task2结束工作
task1返回结果:66  task2返回结果:10
1
2
3
4
5
  1. runAfterBoth 既不能接收入参，也无返回值，待前两个任务执行完成后才能执行。
 public static void main(String[] args) throws ExecutionException, InterruptedException {

        CompletableFuture<Integer> task1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("task开始工作");
            int num = RandomUtil.randomInt(0, 100);
            System.out.println("task结束工作");
            return num;
        });


        CompletableFuture<Integer> task2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("task2开始工作");
            int num = RandomUtil.randomInt(0, 100);
            System.out.println("task2结束工作");
            return num;
        });

        //通过 runAfterBoth 将两个任务组合起来,待前两个组合任务完成后执行，无入参、无出参
        CompletableFuture<Void> completableFuture = task1.runAfterBoth(task2,()-> {
            System.out.println("task1、task2处理完成" );

        });


        completableFuture.get();


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

输出结果:

task开始工作
task2开始工作
task结束工作
task2结束工作
task1、task2处理完成
1
2
3
4
5

# applyToEither / acceptEither / runAfterEither

这种组合模式只要有一个异步任务成功，就会触发后续的方法，比如我们组合任务1和任务2，如果任务1执行完成就直接执行任务3，无视任务2。反之任务2先完成直接执行任务3，无视任务1。

和上一个组合模式一样，依次规律也是:

  1. 接收入参，含返回值。
 public static void main(String[] args) throws ExecutionException, InterruptedException {

        CompletableFuture<Integer> task = CompletableFuture.supplyAsync(() -> 1);


        CompletableFuture<Integer> task2 = CompletableFuture.supplyAsync(() -> 2);

        CompletableFuture<String> completableFuture = task.applyToEither(task2, (result) -> {
            if (result == 1) {
                System.out.println("task1先完成任务");
                return "task1";
            }
            System.out.println("task2先完成任务");
            return "task2";
        });


        System.out.println("最先完成任务的是:" + completableFuture.get());


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
  1. 接收入参，无返回值。
public static void main(String[] args) throws ExecutionException, InterruptedException {

        CompletableFuture<Integer> task = CompletableFuture.supplyAsync(() -> 1);


        CompletableFuture<Integer> task2 = CompletableFuture.supplyAsync(() -> 2);

        CompletableFuture<Void> completableFuture = task.acceptEither(task2, (result) -> {
            System.out.println("result:" + result);
            if (result == 1) {
                System.out.println("task1先完成任务");
                return;
            }
            System.out.println("task2先完成任务");
        });


        completableFuture.get();


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
  1. 无入参，无返回值。
public static void main(String[] args) throws ExecutionException, InterruptedException {

        CompletableFuture<Integer> task = CompletableFuture.supplyAsync(() -> {
            System.out.println("task1开始工作");
            try {
                TimeUnit.SECONDS.sleep(RandomUtil.randomInt(0,2));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("task1结束工作");
            return 1;
        });


        CompletableFuture<Integer> task2 = CompletableFuture.supplyAsync( () -> {
            System.out.println("task2 开始工作");
            try {
                TimeUnit.SECONDS.sleep(RandomUtil.randomInt(0,2));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("task2 结束工作");
            return 2;
        });

        CompletableFuture<Void> completableFuture = task.runAfterEither(task2, () -> {
            System.out.println("有一个任务完成了");
        });


        completableFuture.get();


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

输出结果

task1开始工作
task2 开始工作
task1结束工作
有一个任务完成了
1
2
3
4

# thenCompose

thenCompose方法会在某个任务执行完成后，将该任务的执行结果作为方法入参然后执行指定的方法，该方法会返回一个新的CompletableFuture实例，例如我们希望任务1执行完成后执行任务2，任务2执行完成后返回执行任务3，最终结果是从任务3中获取。

 public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建异步执行任务:
        CompletableFuture<Integer> task1 = CompletableFuture.supplyAsync(()->{
            System.out.println("task1开始工作");
            int num=RandomUtil.randomInt(0,5);
            try {
                TimeUnit.SECONDS.sleep(num);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("task1结束工作，处理结果："+num);
            return num;
        });


        CompletableFuture<String> task2= task1.thenCompose((r)->{

            System.out.println("task2 开始工作");
            int num=RandomUtil.randomInt(0,5);
            try {
                TimeUnit.SECONDS.sleep(num);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("task2 结束工作");


            return CompletableFuture.supplyAsync(()->{
                System.out.println("task3 开始工作，收到任务1的执行结果:"+r);
                return "task3 finished";
            });
        });

        System.out.println("执行结果->"+task2.get());


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

输出结果:

task1开始工作
task1结束工作，处理结果：1
task2 开始工作
task2 结束工作
task3 开始工作，收到任务1的执行结果:1
执行结果->task3 finished
1
2
3
4
5
6

# allOf / anyOf

allOf返回的CompletableFuture是所有任务都执行完成后才会执行，只要有一个任务执行异常，则返回的CompletableFuture执行get方法时会抛出异常。

public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            // 模拟异步任务1
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            // 模拟异步任务2
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "World";
        });

        CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2);

        allFutures.thenRun(() -> {
            // 所有异步任务完成后打印它们的结果
            String result1 = future1.join();
            String result2 = future2.join();
            System.out.println(result1 + " " + result2);
        });

        // 等待所有异步任务完成
        allFutures.join();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

输出结果:

Hello World
1

而anyOf则是只要有一个任务完成就可以触发后续方法，并且可以返回先完成任务的返回值，这一点和上述applyToEither 例子差不多。

public class Main {

    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            // 模拟异步任务1
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            // 模拟异步任务2
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "World";
        });

        CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(future1, future2);

        anyFuture.thenAccept(result -> {
            // 任何一个异步任务完成后打印它的结果
            System.out.println(result);
        });

        // 等待任何一个异步任务完成
        anyFuture.join();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# 小结

我是 sharkchili ，CSDN Java 领域博客专家，mini-redis的作者，我想写一些有意思的东西，希望对你有帮助，如果你想实时收到我写的硬核的文章也欢迎你关注我的公众号： 写代码的SharkChili 。

同时也非常欢迎你star我的开源项目mini-redis:https://github.com/shark-ctrl/mini-redis (opens new window)

因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注 “加群” 即可和笔者和笔者的朋友们进行深入交流。

# 参考

Java8 CompletableFuture 用法全解:https://blog.csdn.net/qq_31865983/article/details/106137777 (opens new window)

源码解析 Java 的 compareAndSwapObject 到底比较的是什么?:https://blog.csdn.net/qq_40697071/article/details/103374783 (opens new window)

编辑 (opens new window)
上次更新: 2026/03/26, 01:05:31
并发编程ThreadLocal必知必会
CompletableFuture异步IO密集型任务最佳实践

← CompletableFuture异步IO密集型任务最佳实践→

最近更新
01
基于EasyExcel实现高效导出
03-25
02
从开源框架中学习那些实用的位运算技巧
03-25
03
浅谈分布式架构设计思想和常见优化手段
03-25
更多文章>
Theme by Vdoing | Copyright © 2025-2026 Evan Xu | MIT License | 桂ICP备2024034950号 | 桂公网安备45142202000030
×
×