Java多线程-CompletableFuture(链式)

本是古典何须时尚 2023-10-04 23:26 20阅读 0赞

线程池这个大家都知道，是为了提高效率，可以类比生活，如果开个店，需要几个员工，正常的操作都是雇佣员工，而不是每天使用临时工，这样用完就解雇掉，对于店主来说招人的成本太高，还需要培训，我想正常的都不会这么做，线程池也是同样的道理，避免了创建和销毁线程的开销。

Java中经常使用异步执行任务来提高效率，但是获取异步结果需要阻塞主线程，同时可能导致回调地狱问题（多个future对象之间存在依赖组合关系）。于是在Java 1.8中新增了CompletableFuture，让我们可以随意组合各种异步任务的结果。通俗来说就是我们将各个异步任务组成一个任务链，当异步任务完成时会触发这个任务链的下一步执行。

### 创建任务 ###

static ExecutorService executorService = new ThreadPoolExecutor(10, 100,
                10, TimeUnit.MINUTES,
                new LinkedBlockingQueue<Runnable>());
        public static void main(String[] args) {
        
            CompletableFuture<Void> runAsync = CompletableFuture.runAsync(() -> {
        
                System.out.println("runAsync");
            });
            runAsync.join();
        
            CompletableFuture.supplyAsync(() -> {
        
                return "supplyAsync";
            }).thenAccept(System.out::println);
            
            //使用线程池,不使用默认的线程池
            CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
        
                System.out.println("supplyAsync");
                return "supplyAsync";
            }, executorService);
    
    
        	//在主线程中执行
            CompletableFuture<String> message = CompletableFuture.completedFuture("message").
            thenApply(s -> {
        
                System.out.println("thenApplyAsync1: " + s);
                return s.toUpperCase();
            });
        }

### 多任务组合 ###

public static void main(String[] args) throws InterruptedException, IOException, ExecutionException {
        
            CompletableFuture<String> h = CompletableFuture.supplyAsync(() -> {
        
                System.out.println("supplyAsync1");
                return "hello";
            }).thenApply(t -> {
        
                System.out.println("supplyAsync2");
                return t + " ";
            });
            CompletableFuture<String> w = CompletableFuture.supplyAsync(() -> {
        
                System.out.println("supplyAsync3");
                return "world";
            });
            CompletableFuture<String> hw = h.thenCombineAsync(w, (_h, _u) -> {
        
                System.out.println("thenCombineAsync");
                return _h + _u;
            });
        
            Thread.sleep(2000);
            System.out.println("main");
            String s = hw.join();
            System.out.println(s);
        }

> supplyAsync1  
> supplyAsync2  
> supplyAsync3  
> thenCombineAsync  
> main  
> hello world

### 多任务组合优先处理 ###

public static void main(String[] args) throws InterruptedException, IOException, ExecutionException {
        
            CompletableFuture<String> c1 = CompletableFuture.supplyAsync(() -> {
        
                System.out.println("supplyAsync1");
                try {
        
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                return "hello";
            });
            CompletableFuture<String> c2 = CompletableFuture.supplyAsync(() -> {
        
                System.out.println("supplyAsync2");
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                return "world";
            });
       
            CompletableFuture<String> hw = c1.applyToEitherAsync(c2, (_c) -> {
        
                return _c;
            });
            Thread.sleep(2000);
            System.out.println("main");
            String s = hw.join();
            System.out.println(s);
        }

> supplyAsync1  
> supplyAsync2  
> main  
> world

### 流水线处理 ###

public static void main(String[] args) throws InterruptedException, IOException, ExecutionException {
        
            CompletableFuture<String> message = CompletableFuture.completedFuture("message").thenComposeAsync(s -> {
        
                                                            System.out.println("thenComposeAsync1");
                                                            return CompletableFuture.completedFuture(s.toUpperCase()).thenComposeAsync(s1 -> {
        
                                                                System.out.println("thenComposeAsync2");
                                                                return CompletableFuture.completedFuture(s1+"+++++++");
                                                            });
                                                        });
       
            Thread.sleep(2000);
            System.out.println("main");
            String s = message.join();
            System.out.println(s);
            System.in.read();
        }

> thenComposeAsync1  
> thenComposeAsync2  
> main  
> MESSAGE+++++++

### 任务结果处理 ###

public static void main(String[] args) {
        
            CompletableFuture<Void> runAsync = CompletableFuture.supplyAsync(() -> {
        
                return "supplyAsync";
            }).thenApplyAsync((s) -> {
        
                return "thenApplyAsync";
            }).thenAcceptAsync(System.out::println);
            System.out.println("main");
        }

### 多任务同时创建 ###

> 无返回值

public static void main(String[] args) throws InterruptedException, IOException, ExecutionException {
        
            CompletableFuture<Void> voidCompletableFuture = CompletableFuture.allOf(CompletableFuture.runAsync(() -> {
        
                try {
        
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                System.out.println("1");
            }), CompletableFuture.runAsync(() -> {
        
                try {
        
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                System.out.println("2");
            }), CompletableFuture.runAsync(() -> {
        
                try {
        
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                System.out.println("3");
            }));
             
            System.out.println("main");
            System.in.read();
        }

> 优先返回

public static void main(String[] args) throws InterruptedException, IOException, ExecutionException {
        
            CompletableFuture<Object> objectCompletableFuture = CompletableFuture.anyOf(CompletableFuture.supplyAsync(() -> {
        
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                return "1";
            }), CompletableFuture.supplyAsync(() -> {
        
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                return "2";
            }), CompletableFuture.supplyAsync(() -> {
        
                try {
        
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                return "3";
            }));
       
            System.out.println("main");
            objectCompletableFuture.whenComplete((o, throwable) -> {
        
                System.out.println(o);
            });
            System.in.read();
        }

![在这里插入图片描述][241d60d901ab468c8532f2a2d4413093.gif]

点赞 -收藏-关注-便于以后复习和收到最新内容有其他问题在评论区讨论-或者私信我-收到会在第一时间回复在本博客学习的技术不得以任何方式直接或者间接的从事违反中华人民共和国法律,内容仅供学习、交流与参考 免责声明：本文部分素材来源于网络，版权归原创者所有，如存在文章/图片/音视频等使用不当的情况，请随时私信联系我、以迅速采取适当措施，避免给双方造成不必要的经济损失。感谢,配合,希望我的努力对你有帮助^\_^

[241d60d901ab468c8532f2a2d4413093.gif]: https://img-blog.csdnimg.cn/241d60d901ab468c8532f2a2d4413093.gif