completableFuture使用

常用方法

1、join():等待线程执行完成;

2、runAsync和supplyAsync区别:

runAsync 没有返回值

        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("测试执行异步代码");
        });
        future.join();

supplyAsync有返回值

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("有返回值");
            return 1;
        });
        Integer join = future.join();
        System.out.println(join);

3、thenApply方法和thenApplyAsync

thenApply方法根据上一个任务的执行结果为新任务的入参来执行下一个线程有返回值

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("有返回值");
            return 1;
        }).thenApplyAsync((result) -> {
            System.out.println("获取上一级的结果");
            return result+1;
        });
        Integer join = future.join();
        System.out.println(join);

thenApplyAsync 和thenApply的区别：thenApply  子线程也是mian线程  thenApplyAsync 新建线程

4、thenAccept 方法

thenAccept方法根据上一个任务的执行结果为新任务的入参来执行下一个线程无返回值

        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("有返回值");
            return 1;
        }).thenAccept((result) -> {
            System.out.println(result+1);
        });
        future.join();

5、whenComplet方法

 whenComplet 这个方法用于在CompletableFuture完成（无论是正常完成还是抛出异常）时添加一个回调。回调函数有两个参数，一个是结果（如果有的话），另一个是异常（如果有的话）。回调通常用于执行一些后处理任务，如日志记录、清理资源等，但不会阻塞当前线程。

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            return 1;
        }).whenComplete((result, ex) -> {
            if (ex != null) {
                System.out.println("异常原因: " + ex.getMessage());
            } else {
                System.out.println("成功: " + result);
            }
        });
        try{
            Integer join = future.join();
            System.out.println(join);
        }catch (CompletionException e){
            System.out.println(e.getCause());
            System.out.println("失败失败");
        }

特别注意：.whenComplete回调可以处理异常，但.join()或.get()仍会传播异常，除非显式地捕获并处理。

6、exceptionally 遇到异常提供一个备用的返回值

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("An error occurred!");
}).exceptionally(ex -> {
    System.err.println("Caught exception: " + ex.getMessage());
    return "Default value"; // 返回默认值
});

try {
    // 阻塞当前线程，直到future完成
    String result = future.join();
    System.out.println("Result from join: " + result);
} catch (CompletionException e) {
    e.printStackTrace();
}

7、allOf和anyOf方法

allOf  任务并行处理  用来同步等待多个异步任务完成

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            sleep(2000);
            return 1;
        });
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            sleep(1000);
            return 5;
        });
        CompletableFuture.allOf(future, future1);
        System.out.println(future.join());
        System.out.println(future1.join());

anyOf 哪个任务先完成就结束阻塞返回该结果

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            sleep(5000);
            return 1;
        });
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            sleep(1000);
            return 5;
        });
        CompletableFuture<Object> temp = CompletableFuture.anyOf(future, future1);
        System.out.println(temp.join());

8、thenCombine

thenCombine：接收两个已完成阶段的结果（类型为T和U），并返回一个新的结果（类型为V）多个任务完成后合并它们的结果

    //适用于需要提高响应速度或并行处理多个任务的场景。
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            return number + 1;
        });
        CompletableFuture<Integer> async = CompletableFuture.supplyAsync(() -> {
            return number + 2;
        });
        CompletableFuture<Void> tempFuture = CompletableFuture.allOf(future, async);
        try {
            //等待线程执行完成  设置超时时间
            tempFuture.get(1000, TimeUnit.MILLISECONDS);
            DataMap dataMap = new DataMap();
            dataMap.put("future",future.join());
            dataMap.put("async",async.join());
            return dataMap;
        } catch (TimeoutException e) {
            log.error("接口超时===",e);
            return Result.error("接口超时");
        } catch (Exception e) {
            log.error("发生异常===",e);
            return Result.error("系统错误 请查看日志"+e.getMessage());
        }