多线程CompletableFuture之常用方法示例

        多线程开发中CompletableFuture必不可少，对比传统的Thread、ThreadPool，CompletableFuture最大的优势是其非常强大的Future的扩展功能，可以在异步方法中获取返回值，类似前端的Promise，CompletableFuture最常用的方法中，run…方法都是没有返回结果的，supply…方法可以获取返回结果。想要写出高并发的程序需要CompletableFuture的支持，CompletableFuture可以完美解决各类复杂的高并发场景。

前期准备

配置ThreadPoolExecutor线程池，在相关类中把线程池注入进来

@Configuration
public class ThreadPoolExecutorConfig {
    
    
    @Bean
    public ThreadPoolExecutor threadPoolExecutor() {
    
    
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 20, 5, TimeUnit.SECONDS, new ArrayBlockingQueue<>(50));
        executor.allowCoreThreadTimeOut(true);
        return executor;
    }
}

	@Autowired
    private ThreadPoolExecutor executor;

1.runAsync

无返回值异步线程，泛型中为void类型，默认主程序不等待子线程

	@GetMapping("/test1")
    public void test1(){
    
    
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    
    
            try {
    
    
                Thread.sleep(200);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务执行结束");
        }, executor);
        System.out.println("执行主程序结束");
    }

执行结果

执行主程序结束
子线程任务执行结束

2.supplyAsync

有返回值异步线程，线程中必须要返回数据，泛型中的值与线程中的返回值需一致，默认主程序不等待子线程。如果需要获取子线程的返回值，调用get方法，主程序会等待子线程结束后执行

	@GetMapping("/test2")
    public void test2() throws ExecutionException, InterruptedException {
    
    
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    
    
            try {
    
    
                Thread.sleep(200);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务执行结束");
            return "123";
        }, executor);
        System.out.println("执行主程序结束，不考虑返回值");
        System.out.println("执行主程序结束，线程返回值："+future.get());
    }

执行结果

执行主程序结束，不考虑返回值
子线程任务执行结束
执行主程序结束，线程返回值：123

3.thenRunAsync

上一步之后链式调用，一般与runAsync搭配使用，thenRunAsync中的方法在runAsync之后执行

	@GetMapping("/test3")
    public void test3(){
    
    
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    
    
            try {
    
    
                Thread.sleep(200);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务1执行结束");
        }, executor).thenRunAsync(() -> {
    
    
            System.out.println("子线程任务2执行结束");
        });
        System.out.println("执行主程序结束");
    }

执行结果

执行主程序结束
子线程任务1执行结束
子线程任务2执行结束

4.thenAcceptAsync

上一步之后调用（可以获取上一步的返回值），一般与supplyAsync搭配使用，thenAcceptAsync中的方法可以在supplyAsync之后才执行，可以获取supplyAsync的返回值

	@GetMapping("/test4")
    public void test4(){
    
    
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    
    
            try {
    
    
                Thread.sleep(200);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务1执行结束");
            return "456";
        }, executor);
        CompletableFuture<Void> future2 = future1.thenAcceptAsync((s) -> {
    
    
            System.out.println("子线程任务2获取任务1的数据：" + s);
        }, executor);
        System.out.println("执行主程序结束");
    }

执行结果

执行主程序结束
子线程任务1执行结束
子线程任务2获取任务1的数据：456

5.runAfterBothAsync

任务一、二都完成后执行当前任务，二者都要完成，组合任务不获取前两个任务返回值，且自己无返回值

	@GetMapping("/test5")
    public void test5() {
    
    
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    
    
            try {
    
    
                Thread.sleep(200);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务1执行结束");
            return 10 / 2;
        }, executor);
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    
    
            try {
    
    
                Thread.sleep(300);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务2执行结束");
            return "hello";
        }, executor);
        CompletableFuture<Void> future3 = future1.runAfterBothAsync(future2, () -> {
    
    
            System.out.println("子线程任务3执行结束");
        }, executor);
        System.out.println("执行主程序结束");
    }

执行结果

执行主程序结束
子线程任务1执行结束
子线程任务2执行结束
子线程任务3执行结束

6.thenCombineAsync

任务一、二都完成后执行当前任务（可以获取任务一、二的返回值），二者都要完成，组合任务获取前两个任务返回值，且自己有返回值

	@GetMapping("/test6")
    public void test6() throws ExecutionException, InterruptedException {
    
    
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    
    
            try {
    
    
                Thread.sleep(200);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务1执行结束");
            return 10 / 2;
        }, executor);
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    
    
            try {
    
    
                Thread.sleep(300);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务2执行结束");
            return "hello";
        }, executor);
        CompletableFuture<String> future3 = future1.thenCombineAsync(future2, (s1,s2) -> {
    
    
            System.out.println("子线程任务3执行结束");
            return s1 + s2;
        }, executor);
        System.out.println("执行主程序结束，不考虑返回值");
        System.out.println("执行主程序结束，线程返回值：future1 = "+future1.get());
        System.out.println("执行主程序结束，线程返回值：future2 = "+future2.get());
        System.out.println("执行主程序结束，线程返回值：future3 = "+future3.get());
    }

执行结果

执行主程序结束，不考虑返回值
子线程任务1执行结束
执行主程序结束，线程返回值：future1 = 5
子线程任务2执行结束
执行主程序结束，线程返回值：future2 = hello
子线程任务3执行结束
执行主程序结束，线程返回值：future3 = 5hello

7.exceptionally

获取上一步的异常，指定某个任务执行异常时执行的回调方法，会将抛出异常作为参数传递到回调方法中

	@GetMapping("/test7")
    public void test7() throws ExecutionException, InterruptedException {
    
    
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(()->{
    
    
            return 10 / 0;
        }, executor);
        CompletableFuture<Integer> future2 = future1.exceptionally(exception -> {
    
    
            System.out.println("出现异常：" + exception);
            return 10; //出现异常，使用默认返回值
        });
        System.out.println("执行主程序结束，线程返回值："+future2.get());
    }

执行结果

出现异常：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
执行主程序结束，线程返回值：10

8.handle

方法执行完成后的处理，获取返回值，处理异常，与exceptionally类似

	@GetMapping("/test8")
    public void test8() throws ExecutionException, InterruptedException {
    
    
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(()->{
    
    
            return 10 / 0;
        }, executor);
        CompletableFuture<Integer> future2 = future1.handle((result,exception) -> {
    
    
            if (exception == null) {
    
    
                return result;
            }
            System.out.println("handle处理异常：" + exception);
            return 10; //出现异常，使用默认返回值
        });
        System.out.println("执行主程序结束，线程返回值："+future2.get());
    }

执行结果

handle处理异常：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
执行主程序结束，线程返回值：10

9.allOf

阻塞等待所有异步任务返回

	@GetMapping("/test9")
    public void test9() throws ExecutionException, InterruptedException {
    
    
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(()->{
    
    
            try {
    
    
                Thread.sleep(100);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务1执行结束");
        }, executor);
        CompletableFuture<Void> future2 = CompletableFuture.runAsync(()->{
    
    
            try {
    
    
                Thread.sleep(200);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务2执行结束");
        }, executor);
        CompletableFuture<Void> future3 = CompletableFuture.runAsync(()->{
    
    
            try {
    
    
                Thread.sleep(300);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务3执行结束");
        }, executor);
        // 阻塞等待所有异步任务返回
        CompletableFuture.allOf(future1, future2, future3).get();
        System.out.println("执行主程序结束");
    }

执行结果

子线程任务1执行结束
子线程任务2执行结束
子线程任务3执行结束
执行主程序结束

10.anyOf

所有异步任务只要有一个完成

	@GetMapping("/test10")
    public void test10() throws ExecutionException, InterruptedException {
    
    
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(()->{
    
    
            try {
    
    
                Thread.sleep(100);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务1执行结束");
        }, executor);
        CompletableFuture<Void> future2 = CompletableFuture.runAsync(()->{
    
    
            try {
    
    
                Thread.sleep(200);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务2执行结束");
        }, executor);
        CompletableFuture<Void> future3 = CompletableFuture.runAsync(()->{
    
    
            try {
    
    
                Thread.sleep(300);
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
            System.out.println("子线程任务3执行结束");
        }, executor);
        // 阻塞等待某一个异步任务返回
        CompletableFuture.anyOf(future1, future2, future3).get();
        System.out.println("执行主程序结束");
    }

执行结果

子线程任务1执行结束
执行主程序结束
子线程任务2执行结束
子线程任务3执行结束