09_Future 升级版CompletableFuture

最新推荐文章于 2024-06-15 17:15:49 发布
最新推荐文章于 2024-06-15 17:15:49 发布
阅读量124 收藏
点赞数
分类专栏： # 大厂面试 文章标签： java future completable 异步 juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wufagang/article/details/125383853
版权

前言

在这里插入图片描述

Future 的基本知识

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

try {
            FutureTask task = new FutureTask(new myCall());
            Thread t1 =  new Thread(task,"t1");
            t1.start();
            //System.out.println(task.get());
            task.get(1,TimeUnit.SECONDS);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
//            executorService.shutdown();
        }
        System.out.println("main");

class myCall implements Callable<String>{

    @Override
    public String  call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        while (true){
            System.out.println("----");
            Thread.sleep(1000);
            if(Thread.currentThread().isInterrupted()){
                break;
            }
        }
        return "aa";
    }
}

CompletableFuture对Future的改进

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

案例精讲-从电商网站的比价需求谈起

比较简单不赘述了

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

CompletableFuture常用方法

在这里插入图片描述

package com.wfg.futrue;

import java.util.concurrent.*;

/**
 * @author wufagang
 * @description
 * @date 2022年07月02日 19:28
 */
public class CompletableFutureDemo {


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
//        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
//            System.out.println("33333");
//            try {
//                TimeUnit.SECONDS.sleep(2);
//                System.out.println(Thread.currentThread().getName());
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        },executorService);
//        System.out.println(voidCompletableFuture.get());

        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int i = 1/0;
            return "aa";
        },executorService).whenComplete((v, e) -> {
            if (e == null) {
                System.out.println("计算完成，返回结果：" + v);

            }
        }).exceptionally(e -> {
            System.out.println("异常信息" + e.getMessage());
            return null;
        });
        //TimeUnit.SECONDS.sleep(2);
        System.out.println("main。。。。。。");
        executorService.shutdown();
    }
}


package com.wfg.futrue;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.*;

/**
 * @author wufagang
 * @description
 * @date 2022年07月02日 19:28
 */
public class CompletableFutureDemo2 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
       m7();
    }
    public static void m7() throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("A come in");
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 10;
        }).thenCombine(CompletableFuture.supplyAsync(() -> {
            try {
                System.out.println("b com in ");
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 30;
        }), (x, y) -> {
            return x + y;
        });
        System.out.println(integerCompletableFuture.get());
    }
    public static void m6() throws ExecutionException, InterruptedException {
        CompletableFuture<String> c1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("A come in");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "A";
        });
        CompletableFuture<String> c2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("B come in");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "B";
        });
        CompletableFuture<String> c3 = c1.thenCombine(c2, (e, f) -> {
            return e+f;
        });
        System.out.println(c3.get());

    }
    public static void m5() throws ExecutionException, InterruptedException {
        CompletableFuture<String> c1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("A come in");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "A";
        });
        CompletableFuture<String> c2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("B come in");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "B";
        });
        CompletableFuture<String> c3 = c1.applyToEither(c2, f -> {
            return f;
        });
        System.out.println(c3.get());

    }

    public static void m4(){
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        try {
            CompletableFuture<Void> c1 = CompletableFuture.runAsync(() -> {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            },executorService).thenRun(()->{
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }).thenRunAsync(()->{
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }).thenRun(()->{
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            });
            System.out.println(c1.get());
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }

    }
    public static void m3(){
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        try {
            CompletableFuture<Void> c1 = CompletableFuture.runAsync(() -> {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            },executorService).thenRun(()->{
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }).thenRun(()->{
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }).thenRun(()->{
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            });
            System.out.println(c1.get());
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }

    }
    public static void m2(){
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        try {
            CompletableFuture<Void> c1 = CompletableFuture.runAsync(() -> {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }).thenRun(()->{
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }).thenRun(()->{
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }).thenRun(()->{
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            });
            System.out.println(c1.get());
        }catch (Exception e){
            e.printStackTrace();
        }finally {
         executorService.shutdown();
        }

    }
    public static void m1() throws Exception{
        ExecutorService executorService = Executors.newFixedThreadPool(3);
//        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.runAsync(() -> {
//            System.out.println("33333");
//            try {
//                TimeUnit.SECONDS.sleep(2);
//                System.out.println(Thread.currentThread().getName());
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        },executorService);
//        System.out.println(voidCompletableFuture.get());

        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            int i = 1/0;
            return "aa";
        },executorService).whenComplete((v, e) -> {
            if (e == null) {
                System.out.println("计算完成，返回结果：" + v);

            }
        }).exceptionally(e -> {
            System.out.println("异常信息" + e.getMessage());
            return null;
        });
        System.out.println();
        //TimeUnit.SECONDS.sleep(2);
        System.out.println("main。。。。。。");
        executorService.shutdown();
        completableFuture.get();
        completableFuture.join();
    }
}

CompetableFuture和线程池说明

在这里插入图片描述

吴法刚
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用 FutrueTask 和 Callable 实现多线程
实践求真知
03-22 356
一点睛 要创建一个线程，可以继承自Thread类，或者实现Runnable接口，但JUC还提供了另外一种方式，通过Callable + FutureTask创建并使用线程。 1 FutureTask Future是JDK提供用于处理多线程环境异步问题的一种模式，而FutrueTask就是对Future模式的一种实现。下面通过一段对话来理解什么是“Futura模式”。 老板：“小王，把会议纪要整理好给我。” 小王：“好的，没问题。” 随后，小王立刻开始整理，几分...
java future专题 2-1 CompletableFuture源码探秘-基础用法（1）
xxcupid的博客
04-01 430
todo
实践记录：使用了CompletableFuture之后，程序性能提升了三倍
u011277123的博客
07-03 1279
Java知音2020-02-26 11:04:22 CompletableFuture 相比于jdk5所提出的future概念，future在执行的时候支持异步处理，但是在回调的过程中依旧是难免会遇到需要等待的情况。 在jdk8里面，出现了CompletableFuture的新概念，支持对于异步处理完成任务之后自行处理数据。当发生异常的时候也能按照自定义的逻辑来处理。 如何通过使用CompletableFuture提升查询的性能呢？ 下边我举个例子来演示： 首先我们定义一个Use..
CompletableFuture详解~runAsync
热门推荐
小强快跑~~
02-27 3万+
这个例子创建一个一个异步执行的阶段： static void runAsyncExample() { CompletableFuture cf = CompletableFuture.runAsync(() -> { assertTrue(Thread.currentThread().isDaemon()); randomSleep(); }); assertFalse(cf.isDone()); sleepEnough();
CompletableFuture.runAsync的多线程下异步操作
最新发布
Yoke
06-15 940
​​方法是Java中用于创建异步任务的工具，它可以在后台线程中执行指定的任务，并且可以在任务完成后返回结果或执行后续操作。这种方式可以实现多线程下的异步操作。在多线程环境下，使用​可以实现并发执行多个任务，提高程序的性能和效率。每个异步任务都会在独立的线程中执行，互不影响，从而可以充分利用多核处理器的性能。
CompletableFuture的runAsync
Zhang Phil
07-13 2万+
CompletableFuture的runAsyncCompletableFuture的runAsync只是简单的异步执行一个线程，但是它将返回一个CompletableFuture，有了这个CompletableFuture，可以重新组装和调配，这是和一个普通Runnable不同之处。CompletableFuture future = CompletableFuture.runAsync(ne...
使用CompletableFuture.runAsync()来完成异步任务
m0_46539364的博客
01-16 2万+
CompletableFuture 异步编排
使用JAVA CompletableFuture实现流水线化的并行处理，深度实践总结
Moonxiyue的博客
07-26 4142
好啦，关于JAVA中的使用，以及并行编程相关的内容呢就介绍到这里啦。看到这里，相信您应该有所收获吧？那么你的项目里有这种适合并行处理的场景吗？你在处理并行场景的时候是怎么做的呢？评论区一起讨论下吧~~本文中有提及执行时所使用的默认线程池是，早在JAVA7版本就已经被引入，但是很多人对不是很了解，实际项目中使用的也比较少。其实对的合理利用，可以让我们在面对某些多线程场景时会更加的从容高效。在后面的文章中，我会针对有关的内容进行专门的介绍与探讨，如果有兴趣，可以点个关注，及时获取后续的内容。https。...
聊聊接口设计的36个小技巧
m0_69424697的博客
06-02 482
前言大家好，作为后端开发，不管是什么语言，Java、Go还是C++，其背后的后端思想都是类似的。后面打算出一个后端思想的技术专栏，主要包括后端的一些设计、或者后端规范相关的，希望对大家日常工作有帮助哈。我们做后端开发工程师，主要工作就是：如何把一个接口设计好。所以，今天就给大家介绍，设计好接口的36个锦囊。本文就是后端思想专栏的第一篇哈。 小伙伴们有兴趣想了解内容和更多相关学习资料的请点赞收藏+评论转发+关注我，后面会有很多干货。我有一些面试题、架构、设计类资料可以说是程序员面试必备！ 所有资料都整理到网盘
搞定 CompletableFuture，并发异步编程和编写串行程序还有什么区别？你们要的多图长文
日拱一兵
07-21 896
你有一个思想，我有一个思想，我们交换后，一个人就有两个思想 If you can NOT explain it simply, you do NOT understand it well enough 现陆续将Demo代码和技术文章整理在一起 Github实践精选 ，方便大家阅读查看，本文同样收录在此，觉得不错，还请Star???? 前言 上一篇文章 不会用Java Future，我怀疑你泡茶没我快 全面分析了 Future，通过它我们可以获取线程的执行结果，它虽然解决了 Runnable 的
netty-future和promise的演示以及速率控制的案例
shuixiou1的博客
03-20 2674
netty-future和promise的演示以及速率控制的案例 一、future和promise的演示 1、Future Future 模式 是处理异步执行时的一个处理模式，它有二种编程模式。 第一种：将来式- 让执行线程，可以拿到异步调用的一个标记对象，如果执行线程调用future.get(),那么就能够等待异步执行的结果。 第二种：回调式- 通过给Future添加回调的方式，通过回调拿到异步执行的结果 案例1： /** * 案例1：使用JDk的Future模式 -- 将来式 *.
【异步操作工具 CompletableFuture 详解】
Java之行
04-19 2796
CompletableFuture方法详解
JDK：Callable Future FutureTask的区别
工匠精神
04-29 248
在JDK中，我们可以通过以下方式新开线程并执行： 1.继承Thread类，并重写run()方法 public class MyThread extends Thread { @Override public void run() { //开发业务需求 } } 2.实例化Thread的对象，并传递Runnable实现类的对象 Runnable...
JUC并发编程第三篇，CompletableFuture场景练习，电商比价需求性能提升
I wanna be myself, where I Belong.
11-23 432
如果现在有一些网站物品价格初始数据串，我们想要进行比价，可以将这些数据保存到Redis的Zset里边，保证数据没有重复，然后进行比较，第一种笨办法就是一条数据一条数据的过，但是这样性能不高；第二种，在JUC里边，有一个 CompletableFuture，用他做多线程异步并发是不阻塞的，而且可以自定义线程池，线程池根据数据量的大小伸缩，在数据量变大时仍能保证效率，大大提升程序性能。案例说明：电商比价需求。
多线程CompletableFuture之常用方法示例
weixin_50989469的博客
11-06 1402
多线程开发中CompletableFuture必不可少，对比传统的Thread、ThreadPool，CompletableFuture最大的优势是其非常强大的Future的扩展功能，可以在异步方法中获取返回值，类似前端的Promise
Java 多线程工作之CompletableFuture.runAsync案例
u011556070的博客
01-26 3万+
在实际的工作中，我们会需要执行一些无返回的多线程任务以改善系统的运行效率。 接受kafka消息并对这些消息进行处理是一个典型案例，如果这里使用多线程的处理方式可以大大提高系统的处理性能。 以下就对CompletableFuture.runAsync的使用方式做一个案例展示 先定义一个处理的任务，这里可能是一个Runnable也可能是一个Callable，区别就是在于有无返回值 import lombok.extern.slf4j.Slf4j; /** * @author yhgu * @date 20
Java并发编程系列 | FutureTask原理详解
Liu_G的博客
03-03 840
Java并发编程系列文章 欢迎大家观看我的博客，会不断的修正和更新文章，也欢迎大家一起交流 Java并发编程系列 | 原子操作的底层原理 Java并发编程系列 | volatile关键字的原理 Java并发编程系列 | synchronized的锁升级过程 Java并发编程系列 | 线程池原理详解 Java线程池原理详解Java并发编程系列文章FutureTask简介运行流程回答上述的问题 FutureTask简介 依旧是在看hystrix源码的时候，看到它底层实现用到了FutureTask，以前只是学
Java8的CompletableFuture之一
06-01 9287
Java8提供了一种函数风格的异步和事件驱动编程模型CompletableFuture，该模型不同于以往Java版本，不会造成堵塞Blocking。过去，Java 5并发包主要聚焦于异步任务处理，其模型特点是基于一个生产者线程，不断地创造任务，通过一个堵塞Blocking队列传递给任务的消费者，这个模型在Java 7和Java 8以后使用了另外一种任务执行模型，同时将一个任务的数据分解到子集中，这
python __future__
11-19
__future__模块的作用是允许在当前版本的Python中使用将来版本的语言特性。通过导入__future__模块，我们可以使用将来版本的语言特性，这样即使我们的代码在将来的Python版本中运行，也不会出现语法错误。下面是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值