1
import java.time.LocalDate;
2
import java.util.concurrent.*;
3

4
public 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
}

1
import java.util.concurrent.CompletableFuture;
2

3
public 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
}

1
import java.util.concurrent.CompletableFuture;
2

3
public 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
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3
import java.util.ArrayList;
4
import java.util.Arrays;
5
import java.util.List;
6
import java.util.concurrent.CompletableFuture;
7
import java.util.concurrent.atomic.AtomicReference;
8

9
public 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
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3
import java.util.ArrayList;
4
import java.util.Arrays;
5
import java.util.List;
6
import java.util.concurrent.CompletableFuture;
7
import java.util.concurrent.atomic.AtomicReference;
8

9
public 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
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3
import java.util.concurrent.CompletableFuture;
4

5
public 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
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3
import java.util.concurrent.CompletableFuture;
4

5
public 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
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3
import java.util.List;
4
import java.util.concurrent.CompletableFuture;
5
import java.util.concurrent.CopyOnWriteArrayList;
6

7
public 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
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3
import java.util.List;
4
import java.util.concurrent.CompletableFuture;
5
import java.util.concurrent.CopyOnWriteArrayList;
6

7
public 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
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3
import java.util.Random;
4
import java.util.concurrent.CompletableFuture;
5

6
public 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
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3
import java.util.Random;
4
import java.util.concurrent.CompletableFuture;
5

6
public 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
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3
import java.util.concurrent.CopyOnWriteArrayList;
4
import java.util.List;
5
import java.util.Random;
6
import java.util.concurrent.CompletableFuture;
7

8
public 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
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3
import java.util.CopyOnWriteArrayList;
4
import java.util.List;
5
import java.util.Random;
6
import java.util.concurrent.CompletableFuture;
7

8
public 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
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3
import java.util.concurrent.CompletableFuture;
4

5
public 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
}

1
import java.time.LocalDate;
2
import java.time.format.DateTimeFormatter;
3
import java.util.concurrent.CompletableFuture;
4

5
public 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
}

1
import java.util.concurrent.CompletableFuture;
2

3
public 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
}

1
import java.util.concurrent.CompletableFuture;
2

3
public 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
}

1
import java.util.concurrent.CompletableFuture;
2

3
public 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
}

1
import java.util.concurrent.CompletableFuture;
2

3
public 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
}

1
import java.util.concurrent.CompletableFuture;
2

3
public 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
}

1
import java.util.concurrent.CompletableFuture;
2

3
public 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
}

1
import java.util.Random;
2
import java.util.concurrent.CompletableFuture;
3

4
public 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
}

1
import java.util.Random;
2
import java.util.concurrent.CompletableFuture;
3

4
public 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
}

1
import java.util.Random;
2
import java.util.concurrent.CompletableFuture;
3

4
public 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
}

1
import java.util.Random;
2
import java.util.concurrent.CompletableFuture;
3

4
public 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
}

1
import java.util.Random;
2
import java.util.concurrent.CompletableFuture;
3

4
public 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
}