CompletableFuture

最新推荐文章于 2024-07-26 17:03:00 发布

迷茫的羔羊羊

最新推荐文章于 2024-07-26 17:03:00 发布

阅读量101

点赞数

分类专栏：并发编程文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_62565675/article/details/133359938

版权

并发编程专栏收录该内容

27 篇文章 0 订阅

订阅专栏

本文介绍了Java中的Future接口、FutureTask的产生背景和使用优缺点，以及CompletableFuture的引入，展示了其观察者模式和回调机制在提高效率方面的优势。通过实际案例和方法介绍，探讨了如何优化异步任务的执行和结果获取。

摘要由CSDN通过智能技术生成

1.Future接口

Future接口用于定义异步任务有返回值的线程，接口里面定义了相应的规范，可以为主线程开一个分支任务，帮助主线程执行一个很耗时费力的任务，执行完毕后主线程可通过get方法获取结果。

2.FutureTask诞生的原因

异步任务有返回值的线程需要满足三个条件：

多线程
有返回值
异步的任务

实现Runnable接口后重写run方法是没有返回值的，以及不能抛出异常。而callable接口则恰好弥补了有返回值这个需求。

而且我们会发现RunnableFuture恰好继承了Runnable和Future，所以使用RunnableFuture就满足了多线程以及异步的任务这两个要求。

那么现在的痛点就是我们如何把RunnableFuture这个接口的功能和Callable接口的有返回值来结合起来呢，此时FutureTask类就诞生了。

如下图我们得知：FutureTask实现了RunnableFuture接口，并且通过构造方法的方式注入了Callable接口。

3.使用Future的优缺点

优点：

使用线程池+FutureTask能显著的提升程序运行的效率，比单线程执行多个任务的效率要快很多。

缺点：

get()方法容易阻塞，一旦调用get()方法获取结果，如果线程中计算没有完成则容易导致程序进行阻塞。可以设置一个最长的等待时间，如果延期了没有获取到，直接抛出异常(这种方式不推荐)。
isDone()的轮询访问，会耗费大量的CPU资源，也不能及时的获取到结果，但是可以打印显示出进度如何。

Future接口在结果的获取上不是很友好，只能通过阻塞或者轮询的方式得到任务的结果。

4.从Future到CompletableFuture

CompletableFuture提供了一种观察者模式类似的机制，可以让线程任务执行完成后通知监听的一方(回调机制)。

CompletableFuture<返回值类型>分为runAsync无返回值和supplyAsync有返回值两种。创建时如果没有指定线程池，则会使用默认的ForkJoinPool.commonPool线程池(会自动回收，相当于守护线程)。

CompletionStage代表异步计算的一个阶段，一个阶段完成之后可以进行到另一个阶段当中，使得功能更加的强大。

//异步调用，有返回值
 CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
       System.out.println(Thread.currentThread().getName()+"completableFuture");
       return 100;
}).whenComplete((t,u)->{ 	//相当于是前端的 .then((resp)=>{ });
       System.out.println(t);  //拿到返回值 100
       System.out.println(u);  //如果内部出现了异常，输出异常信息
});
System.out.println(completableFuture.get());//get方法外部拿到返回值
System.out.println(completableFuture.join());//join方法外部拿到返回值

引入CompletableFuture后，减少了Future中获取返回值时阻塞和轮询的这种低效率的方式，利用回调，当任务完成或者发生异常时，自动的调用回调方法。

注意：我们尽量要使用自己创建的线程池，因为这样的话我们可以手动的控制线程池的关闭回收的时间，保证在执行回调方法前避免程序结束。

4.1get方法和join方法的区别

如果使用get方法会出现检查异常，我们必须处理异常，或声明或try-catch。

如果使用join方法不会出现检查异常，运行时如果出错，程序会直接报错。

5.CompletableFuture实际使用案例

public class Test1 {

    static List<NetMall> list = Arrays.asList(new NetMall("jd"),
                                                new NetMall("taobao"),
                                                new NetMall("dangdang"));

    //一个个查询
    public static List<String> getPrice(List<NetMall> list, String productName) {
        //《Mysql》 in jd price is 88.05
        return list
                .stream()
                .map(netMall ->
                        String.format("《" + productName + "》" + "in %s price is %.2f",
                                netMall.getNetMallName(),
                                netMall.calcPrice(productName)))
                .collect(Collectors.toList());
    }

    //通过CompletableFuture异步线程来完成
    public static List<String> getPriceByCompletableFuture(List<NetMall> list, String productName) {
        return list.stream().map(netMall ->
                CompletableFuture.supplyAsync(() ->
                        String.format("《" + productName + "》" + "in %s price is %.2f",
                                netMall.getNetMallName(),
                                netMall.calcPrice(productName)))) //Stream<CompletableFuture<String>>
                .collect(Collectors.toList()) //List<CompletableFuture<String>>
                .stream()//Stream<String>
                .map(s -> s.join()).collect(Collectors.toList()); //List<String>
    }

    public static void main(String[] args) {
        long StartTime = System.currentTimeMillis();
        List<String> list1 = getPrice(list, "mysql");
        for (String element : list1) {
            System.out.println(element);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("------costTime: " + (endTime - StartTime) + " 毫秒");

        System.out.println("------------------------------------------------------");
        long StartTime2 = System.currentTimeMillis();
        List<String> list2 = getPriceByCompletableFuture(list, "mysql");
        for (String element : list2) {
            System.out.println(element);
        }
        long endTime2 = System.currentTimeMillis();
        System.out.println("------costTime" + (endTime2 - StartTime2) + " 毫秒");
    }
}

class NetMall {
    private String netMallName;

    public NetMall(String netMallName) {
        this.netMallName = netMallName;
    }

    public String getNetMallName() {
        return netMallName;
    }

    public void setNetMallName(String netMallName) {
        this.netMallName = netMallName;
    }

    public double calcPrice(String productName) {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return ThreadLocalRandom.current().nextDouble() * 2 + productName.charAt(0); //随机生成价格
    }
}

两者运行的结果进行对比：

《mysql》in jd price is 109.42
《mysql》in taobao price is 109.85
《mysql》in dangdang price is 109.28
------costTime: 3092 毫秒   //一个个查询
------------------------------------------------------
《mysql》in jd price is 110.24
《mysql》in taobao price is 110.40
《mysql》in dangdang price is 109.10
------costTime1022 毫秒 //通过CompletableFuture异步线程

6.Completable常用方法介绍

6.1获得结果和触发计算

获取结果：

public T get()
public T get(long timeout,TimeUnit unit)
public T join() ---> 和get()方法功能一样，只是不需要处理检查异常
public T getNow(T valuelfAbsent) ---> 立即获取，如果没完成直接返回入参值，不会阻塞。

主动触发计算：

public boolean complete(T value) ---> 如果没有计算完成则直接打断计算，将value作为线程的返回值，get/join方法获取的就是value值。

6.2对计算结果进行处理

thenApply ——> 计算的结果存在依赖的关系，下一步需要使用到上一步的计算结果，但是如果出现异常，那么就直接停止。
handle ——> 计算的结果也存在依赖的关系，优点是如果出现了异常也可以往下一步走。

thenApply(f -> {
    System.out.println("222");
    return f + 2;
})
handle((f, e) -> {
    System.out.println("3333");
    int i=10/0;
    return f + 2;
})

6.3对计算结果进行消费

接收到任务的处理结果，并消费，无返回结果。

对比补充：

thenRun(Runnable runnable)：任务A执行完执行B，并且不需要A的结果，没有返回值。
thenAccept(Consumer action)：任务A执行完执行B，B需要A的结果，但是任务B没有返回值。
thenApply(Function fn)：任务A执行完执行B，B需要A的结果，同时任务B有返回值。

thenRun和thenRunAsync在线程池使用上的区别：

如果没有传入自定义线程池，都会默认使用线程池ForkJoinPool。
如果使用自定义线程池，使用thenRun方法时，第一个任务和后面的任务都共用一个自定义线程池。

使用thenRunAsync方法时，第一个任务使用的是自定义线程池，后面的使用的是默认的ForkJoinPool。

6.4对计算速度进行选用

applyToEither谁快用谁

CompletableFuture<String> result = CompletableFutureA.applyToEither(CompletableFutureB, f -> {
	return f + " is winner"; //f就是胜利者的返回值
});

6.5对计算结果进行合并

thenCombine将两个任务的结果进行合并，先完成的先等着，等待其他的分支任务。

CompletableFuture<Integer> finalResult = completableFuture1.thenCombine(completableFuture2,(x, y)->{  //x,y是
    System.out.println("----------开始两个结果合并");
    return x + y;
});