Java 中的异步编程工具 CompletableFuture

 1import java.time.LocalDate;
 2import java.util.concurrent.*;
 3
 4public class SupplyExample {
 5
 6   /**
 7       * 创建自定义线程池
 8       *
 9       * @return 自定义线程池
10       */
11    public static ThreadPoolExecutor myThreadPool() {
12        // 核心线程数
13        int coreSize = 10;
14        // 最大线程数
15        int maxSize = 20;
16        // 空闲线程的回收时间和单位
17        TimeUnit timeUnit = TimeUnit.SECONDS;
18        // 空闲线程时间销毁
19        long keepAliveTime = 60L;
20        // 工作队列
21        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(200);
22        // 拒绝策略
23        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
24
25        // 创建并返回自定义线程池
26        return new ThreadPoolExecutor(coreSize, maxSize, keepAliveTime, timeUnit, workQueue, handler);
27    }
28
29   /**
30       * 执行 CompletableFuture.supplyAsync 方法
31       */
32    public static void supplyAsyncExample() {
33        // 自定义线程池
34        ThreadPoolExecutor threadPool = myThreadPool();
35
36        // 执行 CompletableFuture 任务，将日期字符串转换为 LocalDate 日期对象
37        CompletableFuture<LocalDate> cf = CompletableFuture
38                .supplyAsync(() -> LocalDate.parse("2022-06-01"), threadPool);
39
40        // 调用 join 方法进入堵塞状态，直至获取任务执行结果输出到控制台
41        System.out.println(cf.join());
42    }
43
44   /**
45       * main() 方法
46       */
47    public static void main(String[] args) {
48        supplyAsyncExample();
49    }
50
51}

 1import java.util.concurrent.CompletableFuture;
 2
 3public class RunAsyncExample {
 4
 5    public static void runAsyncExample() {
 6        // 调用 runAsync 方法，异步执行 runnable 中的代码逻辑，模拟获取远程信息
 7        CompletableFuture<Void> cf = CompletableFuture.runAsync(() -> System.out.println("模拟获取远程信息并输出到控制台"));
 8
 9        // 调用 join 方法进行等待，获取执行结果
10        cf.join();
11    }
12
13    public static void main(String[] args) {
14        runAsyncExample();
15    }
16
17}

 1import java.util.concurrent.CompletableFuture;
 2
 3public class SupplyAsyncExample {
 4
 5    public static void supplyAsyncExample() {
 6        // 调用 supplyAsync 方法，异步执行 runnable 中的代码逻辑，模拟获取远程信息，然后返回
 7        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
 8            System.out.println("模拟获取远程信息");
 9            return "远程信息";
10        });
11
12        // 调用 join 方法进行等待，获取执行结果
13        String result = cf.join();
14        System.out.println(result);
15    }
16
17    public static void main(String[] args) {
18        supplyAsyncExample();
19    }
20
21}

 1import java.time.LocalDate;
 2import java.time.format.DateTimeFormatter;
 3import java.util.ArrayList;
 4import java.util.Arrays;
 5import java.util.List;
 6import java.util.concurrent.CompletableFuture;
 7import java.util.concurrent.atomic.AtomicReference;
 8
 9public class ThenRunExample {
10    
11    public static void thenRunExample() {
12        // 模拟的远程获取的日期字符串
13        String dateStr = "1995-05-10,2000-03-15";
14        // 原子引用类对象
15        AtomicReference<List<String>> dateStrList = new AtomicReference<>();
16        // LocalDate集合
17        List<LocalDate> dateList = new ArrayList<>();
18
19        // 执行 CompletableFuture 任务
20        // (1) 第一步，先通过 "," 拆分字符串，然后存入原子引用对象包裹的 List 集合中；
21        // (2) 第二步，遍历 List 集合，将拆分后的字符串转换为 LocalDate 对象；
22        CompletableFuture
23                .runAsync(() -> dateStrList.set(Arrays.asList(dateStr.split(","))))
24                .thenRun(() -> dateStrList.get().forEach(v -> dateList.add(LocalDate.parse(v, DateTimeFormatter.ofPattern("yyyy-MM-dd")))))
25                .join();
26
27        // 输出转换结果
28        for (LocalDate localDate : dateList) {
29            System.out.println(localDate.toString());
30        }
31    }
32
33    public static void main(String[] args) {
34        thenRunExample();
35    }
36
37}

 1import java.time.LocalDate;
 2import java.time.format.DateTimeFormatter;
 3import java.util.ArrayList;
 4import java.util.Arrays;
 5import java.util.List;
 6import java.util.concurrent.CompletableFuture;
 7import java.util.concurrent.atomic.AtomicReference;
 8
 9public class ThenRunAsyncExample {
10
11    public static void thenRunAsyncExample() {
12        // 模拟的远程获取的日期字符粗
13        String dateStr = "1995-05-10,2000-03-15";
14        // 原子引用类对象
15        AtomicReference<List<String>> dateStrList = new AtomicReference<>();
16        // LocalDate集合
17        List<LocalDate> dateList = new ArrayList<>();
18
19        // 执行 CompletableFuture 任务
20        // (1) 第一步，先通过 "," 拆分字符串，然后存入原子引用对象包裹的 List 集合中；
21        // (2) 第二步，遍历 List 集合，将拆分后的字符串转换为 LocalDate 对象；
22        CompletableFuture
23                .runAsync(() -> dateStrList.set(Arrays.asList(dateStr.split(","))))
24                .thenRunAsync(() -> dateStrList.get().forEach(v -> dateList.add(LocalDate.parse(v, DateTimeFormatter.ofPattern("yyyy-MM-dd")))))
25                .join();
26
27        // 输出转换结果
28        for (LocalDate localDate : dateList) {
29            System.out.println(localDate.toString());
30        }
31    }
32
33    public static void main(String[] args) {
34        thenRunAsyncExample();
35    }
36
37}

 1import java.time.LocalDate;
 2import java.time.format.DateTimeFormatter;
 3import java.util.concurrent.CompletableFuture;
 4
 5public class ThenApplyExample {
 6
 7    public static void thenApplyExample() {
 8        // 执行 CompletableFuture 串行任务
 9        CompletableFuture<String> cf = CompletableFuture
10                // 第一步，先模拟通过远程结果获取日期字符串；
11                .supplyAsync(() -> "2022-06-01")
12                // 第二步，将日期字符串转换为 LocalDate 日期对象，便于进行逻辑计算；
13                .thenApply(param -> LocalDate.parse(param, DateTimeFormatter.ofPattern("yyyy-MM-dd")))
14                // 第三步，操作日期对象进行计算，在当前日期的基础上+10天，然后将日期对象转换为字符串返回；
15                .thenApply(param -> param.plusDays(10).format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
16
17        // 调用 join 方法进入堵塞状态，直至获取任务执行结果
18        String result = cf.join();
19        System.out.println(result);
20    }
21
22    public static void main(String[] args) {
23        thenApplyExample();
24    }
25
26}

 1import java.time.LocalDate;
 2import java.time.format.DateTimeFormatter;
 3import java.util.concurrent.CompletableFuture;
 4
 5public class ThenApplyAsyncExample {
 6
 7    public static void thenApplyAsyncExample() {
 8        // 执行 CompletableFuture 串行任务
 9        CompletableFuture<String> cf = CompletableFuture
10                // 第一步，先模拟通过远程结果获取日期字符串；
11                .supplyAsync(() -> "2022-06-01")
12                // 第二步，将日期字符串转换为 LocalDate 日期对象，便于进行逻辑计算；
13                .thenApplyAsync(param -> LocalDate.parse(param, DateTimeFormatter.ofPattern("yyyy-MM-dd")))
14                // 第三步，操作日期对象进行计算，在当前日期的基础上+10天，然后将日期对象转换为字符串返回；
15                .thenApplyAsync(param -> param.plusDays(10).format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
16
17        // 调用 join 方法进入堵塞状态，直至获取任务执行结果
18        String result = cf.join();
19        System.out.println(result);
20    }
21
22    public static void main(String[] args) {
23        thenApplyAsyncExample();
24    }
25
26}

 1import java.time.LocalDate;
 2import java.time.format.DateTimeFormatter;
 3import java.util.List;
 4import java.util.concurrent.CompletableFuture;
 5import java.util.concurrent.CopyOnWriteArrayList;
 6
 7public class ThenAcceptExample {
 8
 9    public static void thenAcceptExample() {
10        // 模拟的远程获取的日期字符粗
11        String dateStr = "1995-05-10,2000-03-15";
12        // 存储 LocalDate 的集合
13        List<LocalDate> dateList = new CopyOnWriteArrayList<>();
14
15        // 执行 CompletableFuture 任务
16        CompletableFuture
17                .supplyAsync(() -> dateStr.split(","))
18                .thenAccept(dateArray -> {
19                    for (String s : dateArray) {
20                        dateList.add(LocalDate.parse(s, DateTimeFormatter.ofPattern("yyyy-MM-dd")));
21                    }
22                })
23                .join();
24
25        // 输出转换结果
26        for (LocalDate localDate : dateList) {
27            System.out.println(localDate.toString());
28        }
29    }
30
31    public static void main(String[] args) {
32        thenAcceptExample();
33    }
34
35}

 1import java.time.LocalDate;
 2import java.time.format.DateTimeFormatter;
 3import java.util.List;
 4import java.util.concurrent.CompletableFuture;
 5import java.util.concurrent.CopyOnWriteArrayList;
 6
 7public class ThenAcceptAsyncExample {
 8
 9    public static void thenAcceptAsyncExample() {
10        // 模拟的远程获取的日期字符粗
11        String dateStr = "1995-05-10,2000-03-15";
12        // 存储 LocalDate 的集合
13        List<LocalDate> dateList = new CopyOnWriteArrayList<>();
14
15        // 执行 CompletableFuture 任务
16        CompletableFuture
17                .supplyAsync(() -> dateStr.split(","))
18                .thenAcceptAsync(dateArray -> {
19                    for (String s : dateArray) {
20                        dateList.add(LocalDate.parse(s, DateTimeFormatter.ofPattern("yyyy-MM-dd")));
21                    }
22                })
23                .join();
24
25        // 输出转换结果
26        for (LocalDate localDate : dateList) {
27            System.out.println(localDate.toString());
28        }
29    }
30
31    public static void main(String[] args) {
32        thenAcceptAsyncExample();
33    }
34
35}

 1import java.time.LocalDate;
 2import java.time.format.DateTimeFormatter;
 3import java.util.Random;
 4import java.util.concurrent.CompletableFuture;
 5
 6public class HandleExample {
 7
 8    public static void handleExample() {
 9        // 执行 CompletableFuture 串行任务:
10        // 第一步，获取远程日期字符串，然后返回
11        // 第二步，接收上一步中的日期字符串，将其转换为 `LocalDate` 日期对象
12        CompletableFuture<LocalDate> cf = CompletableFuture
13                .supplyAsync(() -> {
14                    int random = new Random().nextInt(2);
15                    // 50% 概率发生异常
16                    if (random != 0) {
17                        throw new RuntimeException("模拟发生异常");
18                    }
19                    // 50% 概率返回正常值
20                    return "2022-06-01";
21                })
22                .handle((param, exception) -> {
23                    // 如果上一步结果为异常，则返回现在的日期，否则将上一步获取的日期字符串转换为日期对象
24                    if (exception != null) {
25                        return LocalDate.now();
26                    }
27                    return LocalDate.parse(param, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
28                });
29
30        // 调用 join 方法进入堵塞状态，直至获取任务执行结果
31        LocalDate result = cf.join();
32        System.out.println(result);
33    }
34
35    public static void main(String[] args) {
36        handleExample();
37    }
38
39}

 1import java.time.LocalDate;
 2import java.time.format.DateTimeFormatter;
 3import java.util.Random;
 4import java.util.concurrent.CompletableFuture;
 5
 6public class HandleAsyncExample {
 7
 8    public static void handleAsyncExample() {
 9        // 执行 CompletableFuture 串行任务:
10        // 第一步，获取远程日期字符串，然后返回；
11        // 第二步，接收上一步中的日期字符串，将其转换为 LocalDate 日期对象；
12        CompletableFuture<LocalDate> cf = CompletableFuture
13                .supplyAsync(() -> {
14                    int random = new Random().nextInt(2);
15                    // 50% 概率发生异常
16                    if (random != 0) {
17                        throw new RuntimeException("模拟发生异常");
18                    }
19                    // 50% 概率返回正常值
20                    return "2022-06-01";
21                })
22                .handleAsync((param, exception) -> {
23                    // 如果上一步结果为异常，则返回现在的日期，否则将上一步获取的日期字符串转换为日期对象
24                    if (exception != null) {
25                        return LocalDate.now();
26                    }
27                    return LocalDate.parse(param, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
28                });
29
30        // 调用 join 方法进入堵塞状态，直至获取任务执行结果
31        LocalDate result = cf.join();
32        System.out.println(result);
33    }
34
35    public static void main(String[] args) {
36        handleAsyncExample();
37    }
38
39}

 1import java.time.LocalDate;
 2import java.time.format.DateTimeFormatter;
 3import java.util.concurrent.CopyOnWriteArrayList;
 4import java.util.List;
 5import java.util.Random;
 6import java.util.concurrent.CompletableFuture;
 7
 8public class WhenCompleteExample {
 9
10    public static void whenCompleteExample() {
11        // 模拟的远程获取的日期字符粗
12        String dateStr = "1995-05-10,2000-03-15";
13        // 存储 LocalDate 的集合
14        List<LocalDate> dateList = new CopyOnWriteArrayList<>();
15
16        // 执行 CompletableFuture 任务
17        CompletableFuture
18                .supplyAsync(() -> {
19                    int random = new Random().nextInt(2);
20                    if (random == 1){
21                        throw new RuntimeException("模拟发生异常");
22                    }
23                    return dateStr.split(",");
24                })
25                .whenComplete((dateArray, exception) -> {
26                    // 如果上一步执行过程没有发生异常，则将日期字符串转换为日期对象
27                    if (dateArray != null){
28                        for (String s : dateArray) {
29                            dateList.add(LocalDate.parse(s, DateTimeFormatter.ofPattern("yyyy-MM-dd")));
30                        }
31                    }
32                })
33                .join();
34
35        // 输出转换结果
36        for (LocalDate localDate : dateList) {
37            System.out.println(localDate.toString());
38        }
39    }
40
41    public static void main(String[] args) {
42        whenCompleteExample();
43    }
44
45}

 1import java.time.LocalDate;
 2import java.time.format.DateTimeFormatter;
 3import java.util.CopyOnWriteArrayList;
 4import java.util.List;
 5import java.util.Random;
 6import java.util.concurrent.CompletableFuture;
 7
 8public class WhenCompleteAsyncExample {
 9
10    public static void whenCompleteAsyncExample(){
11        // 模拟的远程获取的日期字符粗
12        String dateStr = "1995-05-10,2000-03-15";
13        // 存储 LocalDate 的集合
14        List<LocalDate> dateList = new CopyOnWriteArrayList<>();
15
16        // 执行 CompletableFuture 任务
17        CompletableFuture
18                .supplyAsync(() -> {
19                    int random = new Random().nextInt(2);
20                    if (random == 1){
21                        throw new RuntimeException("模拟发生异常");
22                    }
23                    return dateStr.split(",");
24                })
25                .whenCompleteAsync((dateArray, exception) -> {
26                    // 如果上一步执行过程没有发生异常，则将日期字符串转换为日期对象
27                    if (dateArray != null){
28                        for (String s : dateArray) {
29                            dateList.add(LocalDate.parse(s, DateTimeFormatter.ofPattern("yyyy-MM-dd")));
30                        }
31                    }
32                })
33                .join();
34
35        // 输出转换结果
36        for (LocalDate localDate : dateList) {
37            System.out.println(localDate.toString());
38        }
39    }
40
41    public static void main(String[] args) {
42        whenCompleteAsyncExample();
43    }
44
45}

 1import java.time.LocalDate;
 2import java.time.format.DateTimeFormatter;
 3import java.util.concurrent.CompletableFuture;
 4
 5public class ThenComposeExample {
 6
 7    public static void thenComposeExample() {
 8        // 执行 CompletableFuture 任务
 9        CompletableFuture<String> cf2 = CompletableFuture
10                // 模拟获取远程接口获取创建时间，然后得到结果 "2022-06-01"
11                .supplyAsync(() -> "2022-06-01")
12                // 实现将两个有依赖关系的任务组合在一起，一个用于转换字符串为日期类型，一个用于计算并转换为日期字符串
13                .thenCompose(param -> {
14                    // 将时间字符串转换为 LocalDate 日期类型
15                    LocalDate localDate = LocalDate.parse(param, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
16                    // 最后创建一个新的任务，任务中将 LocalDate 日期+10天，并转换回字符串返回
17                    return CompletableFuture.supplyAsync(() -> localDate
18                            .plusDays(10)
19                            .format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
20                });
21
22        // 进入堵塞状态，等待这些阶段执行完成
23        String result = cf2.join();
24        System.out.println("计算结果:" + result);
25    }
26
27    public static void main(String[] args) {
28        thenComposeExample();
29    }
30
31}

 1import java.time.LocalDate;
 2import java.time.format.DateTimeFormatter;
 3import java.util.concurrent.CompletableFuture;
 4
 5public class ThenComposeAsyncExample {
 6
 7    public static void thenComposeAsyncExample() {
 8        // 执行 CompletableFuture 任务
 9        CompletableFuture<String> cf2 = CompletableFuture
10                // 模拟获取远程接口获取创建时间，然后得到结果 "2022-06-01"
11                .supplyAsync(() -> "2022-06-01")
12                // 实现将两个有依赖关系的任务组合在一起，一个用于转换字符串为日期类型，一个用于计算并转换为日期字符串
13                .thenComposeAsync(param -> {
14                    // 将时间字符串转换为 LocalDate 日期类型
15                    LocalDate localDate = LocalDate.parse(param, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
16                    // 最后创建一个新的任务，任务中将 LocalDate 日期+10天，并转换回字符串返回
17                    return CompletableFuture.supplyAsync(() -> localDate
18                            .plusDays(10)
19                            .format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
20                });
21
22        // 进入堵塞状态，等待这些阶段执行完成
23        String result = cf2.join();
24        System.out.println("计算结果:" + result);
25    }
26
27    public static void main(String[] args) {
28        thenComposeAsyncExample();
29    }
30
31}

 1import java.util.concurrent.CompletableFuture;
 2
 3public class ThenCombineExample {
 4
 5    public static void thenCombineExample() {
 6        // 模拟调用远程接口获取【姓名】
 7        CompletableFuture<String> nameCf = CompletableFuture.supplyAsync(() -> "mydlq");
 8        // 模拟调用远程接口获取【岁数】
 9        CompletableFuture<Integer> ageCf = CompletableFuture.supplyAsync(() -> 18);
10
11        // 执行 CompletableFuture 任务
12        // 并行执行，模拟调用远程接口获取【姓名】，以及获取【岁数】
13        // 然后将获取的【姓名】和【岁数】拼在一起，之后返回新字符串
14        CompletableFuture<String> cf = nameCf.thenCombine(ageCf, (name, age) -> "姓名:" + name + ", 岁数:" + age);
15
16        // 进入堵塞状态，等待这些阶段执行完成后获取结果
17        String info = cf.join();
18        System.out.println(info);
19    }
20
21    public static void main(String[] args) {
22        thenCombineExample();
23    }
24
25}

 1import java.util.concurrent.CompletableFuture;
 2
 3public class ThenCombineAsyncExample {
 4
 5    public static void thenCombineAsyncExample() {
 6        // 模拟调用远程接口获取【姓名】
 7        CompletableFuture<String> nameCf = CompletableFuture.supplyAsync(() -> "mydlq");
 8        // 模拟调用远程接口获取【岁数】
 9        CompletableFuture<Integer> ageCf = CompletableFuture.supplyAsync(() -> 18);
10
11        // 执行 CompletableFuture 任务
12        // 并行执行，模拟调用远程接口获取【姓名】，以及获取【岁数】
13        // 然后将获取的【姓名】和【岁数】拼在一起，之后返回新字符串
14        CompletableFuture<String> cf = nameCf.thenCombineAsync(ageCf, (name, age) -> "姓名:" + name + ", 岁数:" + age);
15
16        // 进入堵塞状态，等待这些阶段执行完成后获取结果
17        String info = cf.join();
18        System.out.println(info);
19    }
20
21    public static void main(String[] args) {
22        thenCombineAsyncExample();
23    }
24
25}

 1import java.util.concurrent.CompletableFuture;
 2
 3public class ThenAcceptBothExample {
 4
 5    public static void thenAcceptBothExample(){
 6        // 模拟调用远程接口获取【姓名】
 7        CompletableFuture<String> nameCf = CompletableFuture.supplyAsync(() -> "mydlq");
 8        // 模拟调用远程接口获取【岁数】
 9        CompletableFuture<Integer> ageCf = CompletableFuture.supplyAsync(() -> 18);
10
11        // 执行 CompletableFuture 任务
12        // 并行执行，模拟调用远程接口获取【姓名】，以及获取【岁数】
13        // 然后将获取的【姓名】和【岁数】输出
14        CompletableFuture<Void> cf = nameCf.thenAcceptBoth(ageCf,
15                (name, age) -> System.out.println("姓名:" + name + ", 岁数:" + age));
16
17        // 进入堵塞状态等待各阶段执行完成
18        cf.join();
19    }
20
21    public static void main(String[] args) {
22        thenAcceptBothExample();
23    }
24
25}

 1import java.util.concurrent.CompletableFuture;
 2
 3public class ThenAcceptBothAsyncExample {
 4
 5    public static void thenAcceptBothAsyncExample() {
 6        // 模拟调用远程接口获取【姓名】
 7        CompletableFuture<String> nameCf = CompletableFuture.supplyAsync(() -> "mydlq");
 8        // 模拟调用远程接口获取【岁数】
 9        CompletableFuture<Integer> ageCf = CompletableFuture.supplyAsync(() -> 18);
10
11        // 执行 CompletableFuture 任务
12        // 并行执行，模拟调用远程接口获取【姓名】，以及获取【岁数】
13        // 然后将获取的【姓名】和【岁数】输出
14        CompletableFuture<Void> cf = nameCf.thenAcceptBothAsync(ageCf,
15                (name, age) -> System.out.println("姓名:" + name + ", 岁数:" + age));
16
17        // 进入堵塞状态等待各阶段执行完成
18        cf.join();
19    }
20
21    public static void main(String[] args) {
22        thenAcceptBothAsyncExample();
23    }
24
25}

 1import java.util.concurrent.CompletableFuture;
 2
 3public class RunAfterBothExample {
 4
 5    public static void runAfterBothExample() {
 6        // CompletableFuture 任务 - 步骤1
 7        CompletableFuture<Void> step1 = CompletableFuture.runAsync(() -> System.out.println("阶段1"));
 8        // CompletableFuture 任务 - 步骤2
 9        CompletableFuture<Void> step2 = CompletableFuture.runAsync(() -> System.out.println("阶段2"));
10
11        // 当【阶段1】和【阶段2】并行执行完成后，则执行特定任务
12        step1.runAfterBoth(step2, ()-> System.out.println("全部阶段完成，执行特定任务"));
13    }
14
15    public static void main(String[] args) {
16        runAfterBothExample();
17    }
18
19}

 1import java.util.concurrent.CompletableFuture;
 2
 3public class RunAfterBothAsyncExample {
 4
 5    public static void runAfterBothAsyncExample() {
 6        // CompletableFuture 任务 - 步骤1
 7        CompletableFuture<Void> step1 = CompletableFuture.runAsync(() -> System.out.println("阶段1"));
 8        // CompletableFuture 任务 - 步骤2
 9        CompletableFuture<Void> step2 = CompletableFuture.runAsync(() -> System.out.println("阶段2"));
10
11        // 当【阶段1】和【阶段2】并行执行完成后，则执行特定任务
12        step1.runAfterBothAsync(step2, ()-> System.out.println("全部阶段完成，执行特定任务"));
13    }
14
15    public static void main(String[] args) {
16        runAfterBothAsyncExample();
17    }
18
19}

 1import java.util.Random;
 2import java.util.concurrent.CompletableFuture;
 3
 4public class ApplyToEitherExample {
 5
 6    public static void applyToEitherExample(){
 7        // 通道1 (模拟获取远程信息)
 8        CompletableFuture<String> channel1 = CompletableFuture.supplyAsync(() -> {
 9            randomSleep(1000);
10            return "阶段1-从通道1成功获取结果";
11        });
12        // 通道2 (模拟获取远程信息)
13        CompletableFuture<String> channel2 = CompletableFuture.supplyAsync(() -> {
14            randomSleep(1000);
15            return "阶段2-从通道2成功获取结果";
16        });
17
18        // 执行 CompletableFuture 任务
19        // 并行执行【任务1】和【任务2】，分别从【通道1】或者【通道2】中获取结果，
20        // 哪个通道先获取结果成功，就使用该结果作为任务的返回结果，也作为下一步任
21        // 务要执行的参数，然后执行下一步操作，执行完成后返回指定值。
22        CompletableFuture<String> channelTask = channel1.applyToEither(channel2, response -> "获取的结果: " + response);
23
24        // 进入堵塞状态，等待这些阶段执行完成后获取结果并输出
25        String result = channelTask.join();
26        System.out.println(result);
27    }
28
29    /**
30     * 指定规定时间内睡眠
31     * @param time 随机睡眠时间
32     */
33    private static void randomSleep(int time) {
34        try {
35            Thread.sleep(new Random().nextInt(time));
36        } catch (InterruptedException e) {
37        }
38    }
39
40    public static void main(String[] args) {
41        applyToEitherExample();
42    }
43
44}

 1import java.util.Random;
 2import java.util.concurrent.CompletableFuture;
 3
 4public class ApplyToEitherAsyncExample {
 5
 6    public static void applyToEitherAsyncExample1(){
 7        // 通道1 (模拟获取远程信息)
 8        CompletableFuture<String> channel1 = CompletableFuture.supplyAsync(() -> {
 9            randomSleep(1000);
10            return "阶段1-从通道1成功获取结果";
11        });
12        // 通道2 (模拟获取远程信息)
13        CompletableFuture<String> channel2 = CompletableFuture.supplyAsync(() -> {
14            randomSleep(1000);
15            return "阶段2-从通道2成功获取结果";
16        });
17
18        // 执行 CompletableFuture 任务
19        // 并行执行【任务1】和【任务2】，分别从【通道1】或者【通道2】中获取结果，
20        // 哪个通道先获取结果成功，就使用该结果作为任务的返回结果，也作为下一步任
21        // 务要执行的参数，然后执行下一步操作，执行完成后返回指定值。
22        CompletableFuture<String> channelTask = channel1.applyToEitherAsync(channel2, response -> "获取的结果: " + response);
23
24        // 进入堵塞状态，等待这些阶段执行完成后获取结果并输出
25        String result = channelTask.join();
26        System.out.println(result);
27    }
28
29    /**
30     * 指定规定时间内睡眠
31     * @param time 随机睡眠时间
32     */
33    private static void randomSleep(int time){
34        try {
35            int randomNumber = new Random().nextInt(time);
36            Thread.sleep(randomNumber);
37        } catch (InterruptedException e) {
38        }
39    }
40
41    public static void main(String[] args) {
42        applyToEitherAsyncExample1();
43    }
44
45}

 1import java.util.Random;
 2import java.util.concurrent.CompletableFuture;
 3
 4public class RunAfterEitherExample {
 5
 6    public static void runAfterEitherExample(){
 7        // 通道1 (模拟向远程通道1写入数据)
 8        CompletableFuture<Void> channel1 = CompletableFuture.runAsync(() -> {
 9            randomSleep(1000);
10            System.out.println("阶段1-执行完成");
11        });
12        // 通道2 (模拟向远程通道2写入数据)
13        CompletableFuture<Void> channel2 = CompletableFuture.runAsync(() -> {
14            randomSleep(1000);
15            System.out.println("阶段2-执行完成");
16        });
17
18        // 执行 CompletableFuture 任务
19        // 并行执行【任务1】和【任务2】，无论哪个任务先执行完成，直接进行下一步任务，执行特定动作
20        channel1.runAfterEither(channel2, () -> System.out.println("任意任务执行完成-执行特定操作")).join();
21    }
22
23    /**
24     * 指定规定时间内睡眠
25     *
26     * @param time 随机睡眠时间
27     */
28    private static void randomSleep(int time) {
29        try {
30            Thread.sleep(new Random().nextInt(time));
31        } catch (InterruptedException e) {
32        }
33    }
34
35    public static void main(String[] args) {
36        runAfterEitherExample();
37    }
38
39}

 1import java.util.Random;
 2import java.util.concurrent.CompletableFuture;
 3
 4public class RunAfterEitherAsyncExample {
 5
 6    public static void runAfterEitherAsyncExample(){
 7        // 通道1 (模拟向远程通道1写入数据)
 8        CompletableFuture<Void> channel1 = CompletableFuture.runAsync(() -> {
 9            randomSleep(1000);
10            System.out.println("阶段1-执行完成");
11        });
12        // 通道2 (模拟向远程通道2写入数据)
13        CompletableFuture<Void> channel2 = CompletableFuture.runAsync(() -> {
14            randomSleep(1000);
15            System.out.println("阶段2-执行完成");
16        });
17
18        // 执行 CompletableFuture 任务
19        // 并行执行【任务1】和【任务2】，无论哪个任务先执行完成，直接进行下一步任务，执行特定动作
20        channel1.runAfterEitherAsync(channel2, () -> System.out.println("任意任务执行完成-执行特定操作")).join();
21    }
22
23
24    /**
25     * 指定规定时间内睡眠
26     *
27     * @param time 随机睡眠时间
28     */
29    private static void randomSleep(int time) {
30        try {
31            Thread.sleep(new Random().nextInt(time));
32        } catch (InterruptedException e) {
33        }
34    }
35
36    public static void main(String[] args) {
37        runAfterEitherAsyncExample();
38    }
39
40}

 1import java.util.Random;
 2import java.util.concurrent.CompletableFuture;
 3
 4public class AcceptEitherExample {
 5
 6    public static void acceptEitherExample() {
 7        // 通道1 (模拟获取远程信息)
 8        CompletableFuture<String> channel1 = CompletableFuture.supplyAsync(() -> {
 9            randomSleep(1000);
10            return "阶段1-成功获取结果";
11        });
12        // 通道2 (模拟获取远程信息)
13        CompletableFuture<String> channel2 = CompletableFuture.supplyAsync(() -> {
14            randomSleep(1000);
15            return "阶段2-成功获取结果";
16        });
17
18        // 执行 CompletableFuture 任务
19        // 并行执行【任务1】和【任务2】，分别从【通道1】或者【通道2】中获取结果，
20        // 哪个通道先获取结果成功，就使用该结果作为任务的返回结果，也作为下一步任
21        // 务要执行的参数，然后执行下一步操作，执行完成后没有返回值。
22        channel1.acceptEither(channel2, result -> System.out.println("获取的结果: " + result)).join();
23    }
24
25    /**
26     * 指定规定时间内睡眠
27     *
28     * @param time 随机睡眠时间
29     */
30    private static void randomSleep(int time) {
31        try {
32            Thread.sleep(new Random().nextInt(time));
33        } catch (InterruptedException e) {
34        }
35    }
36
37    public static void main(String[] args) {
38        acceptEitherExample();
39    }
40
41}

 1import java.util.Random;
 2import java.util.concurrent.CompletableFuture;
 3
 4public class AcceptEitherAsyncExample {
 5
 6    public static void acceptEitherAsyncExample(){
 7        // 通道1 (模拟获取远程信息)
 8        CompletableFuture<String> channel1 = CompletableFuture.supplyAsync(() -> {
 9            randomSleep(1000);
10            return "阶段1-成功获取结果";
11        });
12        // 通道2 (模拟获取远程信息)
13        CompletableFuture<String> channel2 = CompletableFuture.supplyAsync(() -> {
14            randomSleep(1000);
15            return "阶段2-成功获取结果";
16        });
17
18        // 执行 CompletableFuture 任务
19        // 并行执行【任务1】和【任务2】，分别从【通道1】或者【通道2】中获取结果，
20        // 哪个通道先获取结果成功，就使用该结果作为任务的返回结果，也作为下一步任
21        // 务要执行的参数，然后执行下一步操作，执行完成后没有返回值。
22        channel1.acceptEitherAsync(channel2, result -> System.out.println("获取的结果: " + result)).join();
23    }
24    
25    /**
26     * 指定规定时间内睡眠
27     *
28     * @param time 随机睡眠时间
29     */
30    private static void randomSleep(int time){
31        try {
32            Thread.sleep(new Random().nextInt(time));
33        } catch (InterruptedException e) {
34        }
35    }
36
37    public static void main(String[] args) {
38        acceptEitherAsyncExample();
39    }
40
41}

 1import java.util.Map;
 2import java.util.concurrent.CompletableFuture;
 3import java.util.concurrent.ConcurrentHashMap;
 4
 5public class AllOfExample {
 6
 7    public static void allOfExample() {
 8        // 创建聚合数据的 Map 集合
 9        Map<String, String> userMap = new ConcurrentHashMap<>(3);
10
11        // 创建待执行的 Runnable 参数
12        Runnable runnable1 = () -> {
13            System.out.println("任务1-成功获取用户基本信息");
14            userMap.put("userInfo", "{name: mydlq, age: 18}");
15        };
16        Runnable runnable2 = () -> {
17            System.out.println("任务2-成功获取用户头像");
18            userMap.put("avatar", "http://www.xxx.com/avatar");
19        };
20        Runnable runnable3 = () -> {
21            System.out.println("任务3-成功获取用户余额");
22            userMap.put("balance", "1000");
23        };
24
25        // 执行多个 CompletableFuture，需要等待全部完成
26        CompletableFuture<Void> cf = CompletableFuture.allOf(
27                CompletableFuture.runAsync(runnable1),
28                CompletableFuture.runAsync(runnable2),
29                CompletableFuture.runAsync(runnable3)
30        );
31
32        // 进入堵塞状态，等待执行完成
33        cf.join();
34
35        // 输出用户信息
36        System.out.println("获取的用户信息:");
37        for (Map.Entry<String, String> entry : userMap.entrySet()) {
38            System.out.println(entry.getKey() + ": " + entry.getValue());
39        }
40    }
41
42    public static void main(String[] args) {
43        allOfExample();
44    }
45
46}

 1import java.util.Random;
 2import java.util.concurrent.CompletableFuture;
 3import java.util.function.Supplier;
 4
 5public class AnyOfExample {
 6
 7    public static void anyOfExample() {
 8        Supplier<String> supplier1 = () -> {
 9            System.out.println("通道1");
10            return "通道1-成功获取信息";
11        };
12        Supplier<String> supplier2 = () -> {
13            System.out.println("通道2");
14            return "通道2-成功获取信息";
15        };
16        Supplier<String> supplier3 = () -> {
17            System.out.println("通道3");
18            return "通道3-成功获取信息";
19        };
20
21        // 执行多个 CompletableFuture，只要任意一个执行完成就执行下一步
22        CompletableFuture<Object> cf = CompletableFuture.anyOf(
23                CompletableFuture.supplyAsync(supplier1),
24                CompletableFuture.supplyAsync(supplier2),
25                CompletableFuture.supplyAsync(supplier3)
26        );
27
28        // 进入堵塞状态，等待执行完成，输出获取的信息
29        Object result = cf.join();
30        System.out.println(result);
31    }
32
33    /**
34     * 随机睡眠指定时间
35     *
36     * @param time 睡眠时间
37     */
38    public static void randomTimeSleep(int time){
39        try {
40            Thread.sleep(new Random().nextInt(time));
41        } catch (InterruptedException e) {
42            throw new RuntimeException(e);
43        }
44    }
45
46    public static void main(String[] args) {
47        anyOfExample();
48    }
49
50}

 1import java.util.concurrent.CompletableFuture;
 2import java.util.concurrent.ExecutionException;
 3
 4public class GetExample {
 5
 6    public static void getExample() throws ExecutionException, InterruptedException {
 7        // 执行 CompletableFuture 任务
 8        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> "执行结果");
 9
10        // 调用 get 方法进行等待，获取执行结果
11        cf.get();
12    }
13
14    public static void main(String[] args) throws ExecutionException, InterruptedException {
15        getExample();
16    }
17
18}

 1import java.util.concurrent.CompletableFuture;
 2
 3public class JoinExample {
 4
 5    public static void joinExample() {
 6        // 执行 CompletableFuture 任务
 7        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> "执行结果");
 8
 9        // 调用 join 方法进行等待，获取执行结果
10        cf.join();
11    }
12
13    public static void main(String[] args) {
14        joinExample();
15    }
16
17}

 1import java.util.Random;
 2import java.util.concurrent.CompletableFuture;
 3
 4public class GetNowExample {
 5
 6    public static void getNowExample() {
 7        // 执行 CompletableFuture 任务
 8        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
 9            // 睡眠5毫秒
10            sleep(5);
11            return "示例-执行完成";
12        });
13
14        // 随机睡眠1~10毫秒
15        sleep(new Random().nextInt(10));
16
17        // 调用 getNow 方法获取执行结果，如果任务未执行完成则输出设置的默认值
18        String result = cf.getNow("默认值");
19        System.out.println(result);
20    }
21
22    /**
23     * 线程睡眠
24     *
25     * @param millis 睡眠时间(单位:毫秒)
26     */
27    public static void sleep(long millis){
28        try {
29            Thread.sleep(millis);
30        } catch (InterruptedException e) {
31            e.printStackTrace();
32        }
33    }
34
35    public static void main(String[] args) {
36        getNowExample();
37    }
38
39}

 1import java.util.Random;
 2import java.util.concurrent.CancellationException;
 3import java.util.concurrent.CompletableFuture;
 4import java.util.concurrent.ExecutionException;
 5
 6public class CancelExample {
 7
 8    public static void cancelExample() throws ExecutionException, InterruptedException {
 9        // 执行 CompletableFuture 任务
10        CompletableFuture<Void> cf = CompletableFuture.runAsync(() -> {
11            // 随机睡眠1~10毫秒
12            sleep(new Random().nextInt(10));
13            System.out.println("示例-执行任务完成");‘
14        });
15
16        // 随机睡眠1~10毫秒
17        sleep(new Random().nextInt(10));
18
19        // 调用 cancel 方法取消任务
20        boolean cancelResult = cf.cancel(true);
21        System.out.println("取消任务: " + cancelResult);
22
23        // 调用 get 方法获取执行结果，如果取消任务将抛出 CancellationException 异常，这里对该异常进行处理
24        try {
25            cf.get();
26        } catch (CancellationException e) {
27            System.out.println("获取任务失败，任务已经被取消");
28        }
29    }
30
31    /**
32     * 线程睡眠
33     *
34     * @param millis 睡眠时间(单位:毫秒)
35     */
36    public static void sleep(long millis){
37        try {
38            Thread.sleep(millis);
39        } catch (InterruptedException e) {
40            e.printStackTrace();
41        }
42    }
43
44    public static void main(String[] args) throws ExecutionException, InterruptedException {
45        cancelExample();
46    }
47
48}

 1import java.util.concurrent.CompletableFuture;
 2
 3public class IsDoneExample {
 4
 5    public static void isDoneExample() throws InterruptedException {
 6        // 执行 CompletableFuture 任务
 7        CompletableFuture<Void> cf = CompletableFuture.runAsync(() -> System.out.println("任务执行中..."));
 8
 9        // 调用 isDone 方法查看任务是否执行完成
10        System.out.println("任务是否完成: " + cf.isDone());
11
12        // 等待1秒时间
13        Thread.sleep(1000L);
14
15        // 调用 isDone 方法再次查看任务是否执行完成
16        System.out.println("任务是否完成: " + cf.isDone());
17    }
18
19    public static void main(String[] args) throws InterruptedException {
20        isDoneExample();
21    }
22
23}

 1import java.util.concurrent.CompletableFuture;
 2
 3public class IsCancelledExample {
 4
 5    public static void isCancelledExample(){
 6        // 执行 CompletableFuture 任务
 7        CompletableFuture<Void> cf = CompletableFuture.runAsync(() -> System.out.println("执行 CompletableFuture 任务"));
 8
 9        // 调用 cancel 方法取消任务
10        cf.cancel(true);
11
12        // 调用 isCancelled 方法，查询任务是否成功被取消
13        System.out.println("是否取消任务: " + cf.isCancelled());
14    }
15
16    public static void main(String[] args) {
17        isCancelledExample();
18    }
19
20}

 1import java.util.concurrent.CompletableFuture;
 2
 3public class IsCompletedExceptionallyExample {
 4
 5    public static void isCompletedExceptionallyExample() throws InterruptedException {
 6        // 执行 CompletableFuture 任务
 7        CompletableFuture<Void> cf = CompletableFuture.runAsync(() -> {
 8            System.out.println("执行中...");
 9            // 模拟发生异常
10            System.out.println(1/0);
11        });
12
13        // 等待1秒确保任务执行完成
14        Thread.sleep(1000L);
15        
16        // 调用 isCompletedExceptionally 方法验证当前阶段是否异常完成
17        System.out.println("是否异常完成: " + cf.isCompletedExceptionally());
18    }
19
20    public static void main(String[] args) throws InterruptedException {
21        isCompletedExceptionallyExample();
22    }
23
24}

 1import java.util.concurrent.CompletableFuture;
 2import java.util.concurrent.ExecutionException;
 3
 4public class ObtrudeValueExample {
 5
 6    public static void obtrudeValueExample() throws ExecutionException, InterruptedException {
 7        // 执行 CompletableFuture 任务
 8        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> "示例-执行完成");
 9
10        // 设置或重置 get 方法和与其相关方法的返回的值
11        cf.obtrudeValue("示例-强制设置返回值-无论成功失败");
12
13        // 调用 get 方法进行等待，获取执行结果并输出到控制台
14        String result = cf.get();
15        System.out.println(result);
16    }
17
18    public static void main(String[] args) throws ExecutionException, InterruptedException {
19        obtrudeValueExample();
20    }
21
22}

 1import java.util.concurrent.CompletableFuture;
 2import java.util.concurrent.ExecutionException;
 3
 4public class ObtrudeExceptionExample {
 5
 6    public static void obtrudeExceptionExample() throws ExecutionException, InterruptedException {
 7        // 执行 CompletableFuture 任务
 8        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> "示例-执行完成");
 9
10        // 设置 get 方法和与其相关的方法后续执行抛出指定异常
11        cf.obtrudeException(new Exception("未知异常"));
12
13        // 调用 get 方法进行等待，获取执行结果并输出
14        String result = cf.get();
15        System.out.println(result);
16    }
17
18    public static void main(String[] args) throws ExecutionException, InterruptedException {
19        obtrudeExceptionExample();
20    }
21
22}

 1import java.util.concurrent.CompletableFuture;
 2import java.util.concurrent.ExecutionException;
 3
 4public class CompleteExample {
 5
 6    public static void completeExample() throws ExecutionException, InterruptedException {
 7        // 执行 CompletableFuture 任务
 8        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> "示例-执行完成");
 9
10        // 设置或重置 get 方法和与其相关方法的返回的值，任务没有执行完成返回 true，否则返回 false
11        boolean setResult = cf.complete("示例-任务没有完成-设置返回值");
12        System.out.println("设置返回值为执行结果: " + setResult);
13
14        // 调用 get 方法进行等待，获取执行结果并输出
15        String result = cf.get();
16        System.out.println(result);
17    }
18
19    public static void main(String[] args) throws ExecutionException, InterruptedException {
20        completeExample();
21    }
22
23}

 1import java.util.concurrent.CompletableFuture;
 2import java.util.concurrent.ExecutionException;
 3
 4public class CompleteExceptionallyExample {
 5
 6    public static void completeExceptionallyExample() throws ExecutionException, InterruptedException {
 7        // 执行 CompletableFuture 任务
 8        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> "示例-执行完成");
 9
10        // 设置或重置 get 方法和与其相关方法的返回的值，任务没有执行完成返回 true，否则返回 false
11        boolean setResult = cf.completeExceptionally(new Exception("未知异常"));
12        System.out.println("设置返回值为执行结果: " + setResult);
13
14        // 调用 get 方法进行等待，获取执行结果并输出
15        String result = cf.get();
16        System.out.println(result);
17    }
18
19    public static void main(String[] args) throws ExecutionException, InterruptedException {
20        completeExceptionallyExample();
21    }
22
23}

 1import java.util.Random;
 2import java.util.concurrent.CompletableFuture;
 3import java.util.concurrent.ExecutionException;
 4
 5public class ExceptionallyExample {
 6
 7    public static void exceptionallyExample() throws ExecutionException, InterruptedException {
 8        // 执行 CompletableFuture 串行任务，并且使用 exceptionally 方法:
 9        // - 如果 exceptionally 方法的上一阶段执行过程中出现异常，则会执行 exceptionally 阶段；
10        // - 如果 exceptionally 方法的上一阶段执行过程中没有出现异常，则不会执行 exceptionally 阶段；
11        CompletableFuture<String> cf = CompletableFuture
12                // 执行任务，50%概率发生异常，50%概率返回正常值
13                .supplyAsync(() -> {
14                    if (new Random().nextInt(2) != 0) {
15                        throw new RuntimeException("模拟发生异常");
16                    }
17                    return "正常结束";
18                })
19                // 处理上一步中抛出的异常
20                .exceptionally(Throwable::getMessage);
21
22        // 调用 get 方法进行等待，获取执行结果
23        String result = cf.get();
24        System.out.println(result);
25    }
26
27    public static void main(String[] args) throws ExecutionException, InterruptedException {
28        exceptionallyExample();
29    }
30
31}