多线程CompletableFuture之常用方法示例

- 日理万妓 2023-10-07 20:58 4阅读 0赞

#### 文章目录 ####

*   *  前期准备
     *  1.runAsync
     *  2.supplyAsync
     *  3.thenRunAsync
     *  4.thenAcceptAsync
     *  5.runAfterBothAsync
     *  6.thenCombineAsync
     *  7.exceptionally
     *  8.handle
     *  9.allOf
     *  10.anyOf

**多线程开发中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执行结束