【非阻塞】Completefuture以及Guava提供的Future简单例子

最新推荐文章于 2024-12-30 19:37:38 发布
原创 最新推荐文章于 2024-12-30 19:37:38 发布 · 2.5k 阅读 · 7 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
Java

当前文章被收录于：

Java
2 篇文章 0 人学习
订阅专栏 查看详情

Future、JDK1.8后的Completefuture以及Guava提供的Future简单例子

一、前言

Java 1.5开始，提供Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果。

当我们需要一个函数方法时，如果这个函数执行的很慢，啊么我们就要进行等待。但有时候，我们并不急着要结果。

因此，我们可以让被调用者立即返回，让他再后台慢慢处理这个请求。对于调用者来说，则可以先处理一些其他任务，在正真需要数据的场合再去尝试获取需要的数据。

在这里插入图片描述

二、Future

一般地，是配合ExecutorService来使用的
如demo：

/**
 * 简单调用future+callable
 */
public static void demo1() {
    ExecutorService executorService = Executors.newCachedThreadPool();

    Future<Integer> result = executorService.submit(
            new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    return new Random().nextInt();
                }
            }
    );

    executorService.shutdown();

    try {
        System.out.println("result:" + result.get());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * 简单调用futureTask+callable2
 */
public static void demo2() {
    FutureTask<Integer> task = new FutureTask<>(
            new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    return new Random().nextInt();
                }
            }
    );
    new Thread(task).start();
    try {
        System.out.println("result:" + task.get());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * 简单调用futureTask+callable3
 */
public static void demo3() {
    ExecutorService executorService = Executors.newCachedThreadPool();

    FutureTask<Integer> task = new FutureTask<Integer>(
            ()  -> {
                return new Random().nextInt();
            }
    );

    executorService.submit(task);
    try {
        System.out.println("result:" + task.get());
    } catch (Exception e) {
        e.printStackTrace();
    }
    executorService.shutdown();
}

或者以下demo

// 建立线程池 demo1
final static ExecutorService service = Executors.newCachedThreadPool();

public static void demo1() throws InterruptedException, ExecutionException {
    Long t1 = System.currentTimeMillis();

    // 任務1
    Future<Boolean> booleanTask = service.submit(new Callable<Boolean>() {
        @Override
        public Boolean call() throws Exception {
            return true;
        }
    });

    while (true) {
        if (booleanTask.isDone() && !booleanTask.isCancelled()) {
            //模擬耗時
            Thread.sleep(500);
            Boolean result = booleanTask.get();
            System.err.println("BooleanTask: " + result);
            break;
        }
    }

    // 任務2
    Future<String> stringTask = service.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "Hello World";
        }
    });

    while (true) {
        if (stringTask.isDone() && !stringTask.isCancelled()) {
            String result = stringTask.get();
            System.err.println("StringTask: " + result);
            break;
        }
    }


    // 任務3
    Future<Integer> integerTask = service.submit(new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            return new Random().nextInt(100);
        }
    });

    while (true) {
        if (integerTask.isDone() && !integerTask.isCancelled()) {
            Integer result = integerTask.get();
            System.err.println("IntegerTask: " + result);
            break;
        }
    }

    // 執行時間
    System.err.println("time: " + (System.currentTimeMillis() - t1));
}

我们查看Future接口的定义（去除注释）：

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

综上所述，Future就是对于具体的Runable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。
必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果
我们可以通过轮询isDone方法判断其是否完成，但该方法有较多局限。

三、Future的局限性以及同步、异步、阻塞、非阻塞相关

Future很难直接表述多个Future结果之间的依赖性，开发中，我们经常需要达成以下目的：
1、将两个异步计算合并为一个(两个计算之间相互独立，同时第二个又依赖于第一个的结果)
2、等待Future集合中的所有任务都完成
3、仅等待Future集合中最快的任务完成，并返回它的结果

同步和异步：针对应用程序来，关注的是程序中间的协作关系；阻塞与非阻塞：更关注的是单个进程的执行状态。

同步：执行一个操作之后，等待结果，然后才继续执行后续的操作。

异步：执行一个操作后，可以去执行其他的操作，然后等待通知再回来执行刚才没执行完的操作。

阻塞：进程给CPU传达一个任务之后，一直等待CPU处理完成，然后才执行后面的操作。

非阻塞：进程给CPU传达任务后，继续处理后续的操作，隔断时间再来询问之前的操作是否完成。这样的过程其实也叫轮询

四、Future的两个增强API
Java8 CompletableFuture

其实现了CompletionStage和Future接口，因此你可以像Future那样使用它。

四个静态方法用来为一段异步执行的代码创建CompletableFuture对象，方法的参数类型都是函数式接口，所以可以使用lambda表达式实现异步任务
runAsync方法：它以Runnabel函数式接口类型为参数，所以CompletableFuture的计算结果为空。
supplyAsync方法以Supplier函数式接口类型为参数，CompletableFuture的计算结果类型为U。

public static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

其他API可以自行查阅资料，在此贴出一些简单的介绍demo

1、将两个异步计算合并为一个(这两个异步计算之间相互独立，同时第二个又依赖于第一个的结果)

/**
 * CompletableFuture的hello world join方法官方解释[Returns the result value when complete]
 */
public static void demo4() {
    String result = CompletableFuture.supplyAsync(
            () -> {
                System.out.println("build hello");
                return "hello";
            }
    ).thenApplyAsync(
            r -> {
                System.out.println("build world");
                return r + " world";
            }
    ).join();
    System.out.println(result);
}

2、同上，但是不返回最后结果，仅做逻辑处理

/**
 * CompletableFuture,最后使用thenAccept消费结果，并不产生返回值
 */
public static void demo5() {
    CompletableFuture.supplyAsync(() -> "hello").thenApplyAsync(r -> r + " world").thenAccept(System.out::println);
}

3、多任务结果合并处理后返回

/**
 * thenCombine 结合两个CompletionStage的结果，返回。 如果是消费结果不反回用thenAcceptBoth
 */
public static void demo6() {
    String result = CompletableFuture.supplyAsync(() -> {
        try {
            Thread.sleep(1000);
            System.out.println("build hello");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "hello";
    }).thenCombine(CompletableFuture.supplyAsync(() -> {
        try {
            System.out.println("build world");
            Thread.sleep(2000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return " world";
    }),(s1,s2) -> s1 + s2).join();

    System.out.println(result);
}

4、择优

/**
 * applyToEither可以在两个CompletionStage中选去计算的快的结果返用于下一步的处理
 */
public static void demo7() {
    String result = CompletableFuture.supplyAsync(() -> {
        try {
            Thread.sleep(2000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "Hi boy";
    }).applyToEither(CompletableFuture.supplyAsync(() -> {
        try {
            Thread.sleep(300);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "Hi girl";
    }),s -> s).join();

    System.out.println(result);
}

5、补偿机制

/**
 * 运行时出现异常，可以通过exceptionally进行补偿
 */
public static void demo8() {
    String result = CompletableFuture.supplyAsync(() -> {
       try {
           Thread.sleep(2000);
       } catch (Exception e) {
           e.printStackTrace();
       }
       int a = 10;
       a = a / 0;
       a = a++;
       return "hi boy";
    }).exceptionally(e -> {
        System.out.println(e.getMessage());
        return "hello world";
    }).join();

    System.out.println(result);
}
Google Guava ListenableFuture

其特点：
1、减少主函数的等待时间，使得多任务能够异步非阻塞执行

2、ListenableFuture顾名思义就是可以监听的Future，它是对java原生Future的扩展增强。

3、我们知道Future表示一个异步计算任务，当任务完成时可以得到计算结果。
如果我们希望一旦计算完成就拿到结果展示给用户或者做另外的计算，就必须使用另一个线程不断的查询计算状态。这样做，代码复杂，而且效率低下。
使用ListenableFuture Guava帮我们检测Future是否完成了，如果完成就自动调用回调函数，这样可以减少并发程序的复杂度。

4、ListenableFuture是一个接口，它从jdk的Future接口继承，添加了void addListener(Runnable listener, Executor executor)方法。

demo：

public static void demo2() throws Exception {
    Long t1 = System.currentTimeMillis();
    // 任务1
    ListenableFuture<Boolean> booleanTask = service.submit(new Callable<Boolean>() {
        @Override
        public Boolean call() throws Exception {
            return true;
        }
    });

    Futures.addCallback(booleanTask, new FutureCallback<Boolean>() {
        @Override
        public void onSuccess(Boolean result) {
            System.err.println("BooleanTask: " + result);
        }

        @Override
        public void onFailure(Throwable t) {
        }
    },service);

    // 任务2
    ListenableFuture<String> stringTask = service.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
            return "Hello World";
        }
    });

    Futures.addCallback(stringTask, new FutureCallback<String>() {
        @Override
        public void onSuccess(String result) {
            System.err.println("StringTask: " + result);
        }

        @Override
        public void onFailure(Throwable t) {
        }
    },service);

    // 任务3
    ListenableFuture<Integer> integerTask = service.submit(new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            return new Random().nextInt(100);
        }
    });

    Futures.addCallback(integerTask, new FutureCallback<Integer>() {
        @Override
        public void onSuccess(Integer result) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.err.println("IntegerTask: " + result);
        }

        @Override
        public void onFailure(Throwable t) {
        }
    },service);

    // 执行时间
    System.err.println("time: " + (System.currentTimeMillis() - t1));
}
标签
#java #非阻塞 #future
CompleteFuture的介绍和使用
weixin_59244784的博客
08-19 1万+
CompleteFuture的介绍和使用
CompleteFuture异步处理和多线程异步处理有什么区别
优秀的程序员不应该是CRUD
05-12 2955
CompleteFuture是Java SE 8中新增的一个异步处理工具类，它可以将一个异步的操作封装为一个Future对象，并允许你设置一个回调函数在操作完成后执行。而多线程异步处理是通过创建线程来执行并行任务，以达到异步处理的效果。可以看到，使用 CompleteFuture 可以通过 thenAccept() 方法来设置异步操作完成后的回调函数。这个回调函数将在指定的线程池执行，参数是异步操作的返回值，而且不会阻塞主线程的执行。两者的区别在于实现方式不同。
CompleteFuture详解
最新发布
Linging_24的博客
12-30 4823
如上图所示，这里描绘的是一个业务接口的流程，其中包括CF1/CF2/CF3/CF4/CF5共5个步骤，并描绘了这些步骤之间的依赖关系，每个步骤可以是一次RPC调 用、一次数据库操作或者是一次本地方法调用等，在使用CompletableFuture进行 异步化编程时，图中的每个步骤都会产生一个CompletableFuture对象，最终结果 也会用一个CompletableFuture来进行表示。传递时使用指定线程池中的线程，当不传递时，会使用ForkJoinPool中的共用线程池 CommonPool。
java并发编程中Future、CompleteFuture、ForkJoin的应用
qq_42003636的博客
01-14 6079
Future一、应用场景● 在并发编程中，我们经常用到非阻塞的模型，在之前的多线程的三种实现中，不管是继承thread类还是实现runnable接口，都无法保证获取到之前的执行结果。通过实现Callback接口，并用Future可以来接收多线程的执行结果。● Future表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加Callback以便在任务执行成功或失败后作出相应的操作。
Java8 CompleteFuture简单使用
热门推荐
DJH2717的博客
05-02 3万+
Java8 中的 completeFuture 是对 Future 的扩展实现, 主要是为了弥补 Future 没有相应的回调机制的缺陷. 我们先看看 Java8 之前的 Future 的使用: package demos; import java.util.concurrent.ExecutionException; import java.util.concurrent.Execu...
返回CompletableFuture：Java 8功能亮点
最佳 Java 编程
06-03 518
CompletableFuture与未来：与Java 8新功能保持异步 Java 8于2014年3月发布，并附带了许多新功能。 鲜为人知的，极为有用却被人误解的功能之一是对Future接口的全新改进，即扩展：CompletableFuture <T>。 在下面的文章中，我们将提供CompletableFuture的整体视图，以及它与简单的Future有何不同以及何时有用。...
java 8特性 - CompletableFuture 笔记
Fred's Note
02-17 676
【参考资料】 【1】https://blog.csdn.net/qq_39172525/article/details/86655590 【2】https://blog.csdn.net/u014209205/article/details/80598209 1. future 1.1 future 类图 1.2 future 定义 public interface Future<V> { boolean cancel(boolean mayInterruptIfRunning); /
Java8新的异步编程方式 CompletableFuture
z69183787的专栏
02-13 764
一. Future JDK 5引入了Future模式。Future接口是Java多线程Future模式的实现，在java.util.concurrent包中，可以来进行异步计算。 Future模式是多线程设计常用的一种设计模式。Future模式可以理解成：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后，我就便可以从Future那...
【异步编程】CompletableFuture的complete/get方法介绍
鹏啊鹏
07-20 5484
CompletableFuture的complete和get方法介绍。
Future & CompleteFuture
yy139926的博客
02-08 3647
Java8 中的 completeFuture 是对 Future 的扩展实现, 主要是为了弥补 Future 没有相应的回调机制的缺陷。
通俗易懂的CompletableFuture详解
Tech in Pieces
12-05 8656
我们有了Future和Executor来执行我们的异步任务 为什么还需要这个？ 当我们用Future获得异步执行结果 有两种方法：调用Get()或者轮询isDOne()是否为True. 这两种方法都不是太好，因为主线程也会被迫等待。 为了减少这种等待 JAVA8引入了这个CP 对Future做了改进 可以传入回调对象。 这个类都包含什么方法，怎么用？ 方法很多 大概有50个 单纯一个个记忆，是很麻烦的，因此将其划分为以下几类： 创建类 completeFuture 可以用于创建默认返回值 runAsync
【Java】 Java CompleteFuture 分析
@李法新
10-10 960
可以使用CompletableFuture.supplyAsync()或CompletableFuture.runAsync()方法来创建CompleteFuture。supplyAsync()方法用于异步计算一个结果，runAsync()方法用于异步执行一个操作。CompleteFuture是Future的扩展版本，它提供了更灵活和更强大的方法来处理异步操作的结果。CompleteFuture还提供了一些方法来处理异常和其他状态，以及一些方法来合并多个CompleteFuture实例。
CompleteFuture实现简单的任务编排实践
flw7758的博客
10-18 1717
CompleteFuture实现简单的任务编排实践 一：前言 ​ CompleteFuture是java8 新提供的API，是对函数式编程思想的体现，提供了很多的对于函数式编程支持。不止有同步处理功能，还有异步处理能力。 通过函数式编程可以实现线程的简单任务编排。高效，整洁实现多线程异步编程。 二：详细介绍 ​ CompleteFuture 提供的API中以ansy结尾的都是异步处理的。 异步执行任务，并返回结果：supplyAsync 异步处理，并返回结果，默认使用ForkJoinPool.commo
JUC高并发编程(17) -- CompletableFuture
姜皓的博客
05-13 359
CompletableFuture
CompletableFuture详解。
2401_89221867的博客
11-29 1595
它返回一个新的 CompletableFuture，当任意一个给定的 CompletableFuture 完成时，这个新的 CompletableFuture 也会完成，并且它的结果就是那个最先完成的 CompletableFuture 的结果。它返回一个新的 CompletableFuture，当所有给定的 CompletableFuture 都完成时，这个新的 CompletableFuture 也会完成。.commonPool()）执行异步任务，另一个可以传入一个自定义的线程池来执行异步任务。
CompleteFuture与Future的比较
技术人集结地
12-18 3222
CompletableFuture是Java 8提供的一种基于Future的异步编程的实现。它不仅可以代表异步计算的结果，还能够定义它完成之后的回调函数。它的实现在java.util.concurrent.CompletableFuture的包内。CompletableFuture的实现涉及到JDK 8的几个新特性，如Lambda、Stream、线程池等，它允许把任务池、线程池和阻塞队列组合在一起，使得开发者可以更加简单地实现异步编程，对程序的执行性能也带来了一定的提升。
CompleteFuture全方法说明
曲怪曲怪
12-19 8603
CompleteFuture 全方法说明
CompleteFuture异步执行失败却返回成功
记录、总结
03-20 914
1、自定义线程池编写三个简单的异步任务，在第三个任务执行时制造异常程序执行结果控制台却打印了异常信息，异步任务自己捕获并抛出了异常信息，但是最外成决定程序执行成功失败的try-catch没有捕获到异常信息，所以返回成功。解决办法就是让异步任务生成CompleteFuture，并调用get()方法或者join()，注意：异步任务中get()是阻塞的，使用时需要添加超时时间。再次执行程序，就能返回接口正确的执行结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值