38. anyOf：多个任务谁先完成就用谁

38. anyOf：多个任务谁先完成就用谁

前面学过：

CompletableFuture.allOf(...)

它的作用是等待一批异步任务全部完成。

这一节看另一个方法：

CompletableFuture.anyOf(...)

它解决的是另一种情况：

我同时启动多个异步任务；

不需要等待所有任务结束；

只要其中任意一个任务先完成，就先使用它的结果。

比如我有三个文件服务，都能返回同一个 PDF 的下载地址：

服务一：阿里云对象存储；

服务二：腾讯云对象存储；

服务三：本地备用存储。

我可以同时请求三个服务。

谁先返回，就先使用谁的结果。

这种场景适合使用：

anyOf(...)

---

anyOf 的基本写法

先看一个简单例子：

CompletableFuture<String> future1 =
        CompletableFuture.supplyAsync(() -> {
            sleep(3000);
            return "任务一完成";
        });

CompletableFuture<String> future2 =
        CompletableFuture.supplyAsync(() -> {
            sleep(1000);
            return "任务二完成";
        });

CompletableFuture<String> future3 =
        CompletableFuture.supplyAsync(() -> {
            sleep(2000);
            return "任务三完成";
        });

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

Object result = anyFuture.join();

System.out.println("最先完成的结果：" + result);

三个任务的耗时分别是：

任务一：3 秒；

任务二：1 秒；

任务三：2 秒。

所以 future2 大概率最先完成。

最终输出：

最先完成的结果：任务二完成

---

完整示例

新建类：

com.succos.completablefuture.AnyOfDemo

代码如下：

package com.succos.completablefuture;

import java.util.concurrent.CompletableFuture;

public class AnyOfDemo {

    public static void main(String[] args) {

        CompletableFuture<String> future1 =
                CompletableFuture.supplyAsync(() -> {

                    System.out.println("任务一开始："
                            + Thread.currentThread().getName());

                    sleep(3000);

                    System.out.println("任务一完成");

                    return "任务一结果";
                });

        CompletableFuture<String> future2 =
                CompletableFuture.supplyAsync(() -> {

                    System.out.println("任务二开始："
                            + Thread.currentThread().getName());

                    sleep(1000);

                    System.out.println("任务二完成");

                    return "任务二结果";
                });

        CompletableFuture<String> future3 =
                CompletableFuture.supplyAsync(() -> {

                    System.out.println("任务三开始："
                            + Thread.currentThread().getName());

                    sleep(2000);

                    System.out.println("任务三完成");

                    return "任务三结果";
                });

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

        Object result = anyFuture.join();

        System.out.println("--------------------------------");
        System.out.println("最先完成的结果：" + result);
    }

    private static void sleep(long millis) {

        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("任务被中断", e);
        }
    }
}

运行时可能看到：

任务一开始：ForkJoinPool.commonPool-worker-1
任务二开始：ForkJoinPool.commonPool-worker-2
任务三开始：ForkJoinPool.commonPool-worker-3

任务二完成

最先完成的结果：任务二结果

anyOf().join() 在任务二完成以后就能返回。

它不会继续等待任务一和任务三。

---

anyOf 返回 CompletableFuture