JAVA中的异步CompletableFuture

最新推荐文章于 2024-06-19 12:26:36 发布
最新推荐文章于 2024-06-19 12:26:36 发布
阅读量2.4k 收藏 6
点赞数 2
分类专栏： 我是架构师 文章标签： lambda Future Completable 异步 异步任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingtok/article/details/124098691
版权

JAVA中的异步CompletableFuture

一. 前置知识

参考1
参考2

1.1 异步

首先来看一下异步模型。在异步模型中，允许同一时间发生（处理）多个事件。程序调用一个耗时较长的功能（方法）时，它并不会阻塞程序的执行流程，程序会继续往下执行。当功能执行完毕时，程序能够获得执行完毕的消息或能够访问到执行的结果（如果有返回值或需要返回值时）。

1.2 多线程

多线程是指同时并发或并行执行多个指令（线程）。

在单核处理器上，多线程往往会给人程序是在并行执行的错觉。实际上，处理器是通过调度算法在多线程之间进行切换和调度。或者根据外部输入（中断）和线程的优先级的组合来进行线程的切换。

在多核处理器上，线程才是真正的并行运行。多个处理器同时执行多个线程，以达到更加高效的处理。

一个简单的示例就是：开启两个浏览器窗口同时下载两个文件。每个窗口都使用一个新的线程去下载文件，它们之间并不需要谁等待谁完成，而是并行进行下载。

二. Future模式

Future模式不会立即返回你需要的数据，但是，他会返回一个契约 ，以后在使用到数据的时候就可以通过这个契约获取到需要的数据。

在这里插入图片描述
原始串行处理程序需要登上一个调用完成后才能进行下一步操作,但这个时候的等待可以是非必要的
在这里插入图片描述

在Future模式中，虽然获取数据是一个耗时的操作，但是服务程序不等数据完成就立即返回客户端一个伪造的数据（就是上述说的“契约”），实现了Future模式的客户端并不急于对其进行处理，而是先去处理其他业务，充分利用了等待的时间，这也是Future模式的核心所在，在完成了其他数据无关的任务之后，最后在使用返回比较慢的Future数据。这样在整个调用的过程中就不会出现长时间的等待，充分利用时间，从而提高系统效率。

2.1 JDK的Future模式
package DataStructure.Future;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.concurrent.*;

@Data
@AllArgsConstructor
public class RealData implements Callable<String> {

    private String result;

    @Override
    public String call() throws Exception {
        StringBuffer sb = new StringBuffer();
        sb.append(result);
        //模拟耗时的构造数据过程
        Thread.sleep(5000);
        return sb.toString();
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new RealData("Hello"));

        ExecutorService executorService = Executors.newFixedThreadPool(1);
        executorService.execute(futureTask);

        System.out.println("请求完毕！");

        try {
            Thread.sleep(2000);
            System.out.println("这里经过了一个2秒的操作！");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("真实数据：" + futureTask.get());
        executorService.shutdown();
    }
}

实现类图
在这里插入图片描述

这里开了一个线程池异跑异步任务,在继承callable接口的call方法中 手动延时构造获取真实数据的时间,最终在五秒后拿到真实数据

FutureTask实现了RunnableFuture接口，RunnableFuture接口继承了Future和Runnable接口。因为RunnableFuture实现了Runnable接口，因此FutureTask可以提交给Executor进行执行，FutureTask有两个构造方法，如下：

  • 计算完成后只能使用 get 方法来获取结果，如果线程没有执行完，Future.get()方法可能会阻塞当前线程的执行；

  • 如果线程出现异常，Future.get()会throws InterruptedException或者ExecutionException；

  • 如果线程已经取消，会抛出CancellationException。取消由cancel 方法来执行。isDone确定任务是正常完成还是被取消了。

  • 一旦计算完成，就不能再取消计算。如果为了可取消性而使用 Future 但又不提供可用的结果，则可以声明Future<?> 形式类型、并返回 null 作为底层任务的结果。

三. CompletableFuture

CompletableFuture实现异步

public static void main(String[] args) throws Exception {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(CompletableFutureTest::fetchPrice);
        // 如果执行成功:
        cf.thenAccept((result) -> {
            System.out.println("price: " + result);
        });
        // 如果执行异常:
        cf.exceptionally((e) -> {
            e.printStackTrace();
            return null;
        });
        // 主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭:
        Thread.sleep(200);
    }

    static Double fetchPrice() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
        }
        if (Math.random() < 0.3) {
            throw new RuntimeException("fetch price failed!");
        }
        return 5 + Math.random() * 20;
    }

supplyAsync 提供CompletableFuture泛型容器,thenAccept异步接收回调,exceptionally如果出现异常则调用
在这里插入图片描述

3.1 串行异步任务

串行执行异步任务 1.首先异步获取商品编码 2.然后异步获取商品价格

 // 串行执行异步任务 1.首先异步获取商品编码 2.然后异步获取商品价格
        public static void main(String[] args) throws Exception {
            // 第一个任务:
            CompletableFuture<String> cfQuery = CompletableFuture.supplyAsync(() -> {
                return queryCode("商品1");
            });
            // cfQuery成功后继续执行下一个任务:
            CompletableFuture<Double> cfFetch = cfQuery.thenApplyAsync((code) -> {
                return fetchPrice(code);
            });
            // cfFetch成功后打印结果:
            cfFetch.thenAccept((result) -> {
                System.out.println("price: " + result);
            });
            // 主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭:
            Thread.sleep(2000);
        }

        static String queryCode(String name) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            return "123456";
        }

        static Double fetchPrice(String code) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            return Math.random() * 100;
        }
3.2 并行异步任务
 public static void main(String[] args) throws Exception {
        // 两个CompletableFuture执行异步查询:
        CompletableFuture<String> cfQueryFromSina = CompletableFuture.supplyAsync(() -> {
            return queryCode("商品1", "https://finance.sina.com.cn/code/");
        });
        CompletableFuture<String> cfQueryFrom163 = CompletableFuture.supplyAsync(() -> {
            return queryCode("商品2", "https://money.163.com/code/");
        });

        // 用anyOf合并为一个新的CompletableFuture:
        CompletableFuture<Object> cfQuery = CompletableFuture.anyOf(cfQueryFromSina, cfQueryFrom163);

        // 两个CompletableFuture执行异步查询:
        CompletableFuture<Double> cfFetchFromSina = cfQuery.thenApplyAsync((code) -> {
            return fetchPrice((String) code, "https://finance.sina.com.cn/price/");
        });
        CompletableFuture<Double> cfFetchFrom163 = cfQuery.thenApplyAsync((code) -> {
            return fetchPrice((String) code, "https://money.163.com/price/");
        });

        // 用anyOf合并为一个新的CompletableFuture:
        CompletableFuture<Object> cfFetch = CompletableFuture.anyOf(cfFetchFromSina, cfFetchFrom163);

        // 最终结果:
        cfFetch.thenAccept((result) -> {
            System.out.println("price: " + result);
        });
        // 主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭:
        Thread.sleep(200);
    }

    static String queryCode(String name, String url) {
        System.out.println("query code from name: "+name +", url: "+ url + "...");
        try {
            Thread.sleep((long) (Math.random() * 100));
        } catch (InterruptedException e) {
        }
        if(name.equals("商品1")) {
            return "1";
        }
        return "2";
    }

    static Double fetchPrice(String code, String url) {
        System.out.println("query price from code:"+ code+ ",  url: " + url + "...");
        try {
            Thread.sleep((long) (Math.random() * 100));
        } catch (InterruptedException e) {
        }
        if(code.equals("1")) {
            return 1.0;
        }
        return 2.0;
    }
  • 1. 开启两个异步任务执行查询商品编码
  • 2. anyOf()其中一个返回即可执行下一步,再开启两个异步任务并行执行上一步查询的编码查价格
  • 3. 最终thenAccept接受结果
3.3 exceptionally
@Test
    public void test2() throws Exception {
        ForkJoinPool pool=new ForkJoinPool();
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+"job1 start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(false){
                throw new RuntimeException("test");
            }else{
                System.out.println(Thread.currentThread()+"job1 exit,time->"+System.currentTimeMillis());
                return 1.2;
            }
        },pool);
        //cf执行异常时，将抛出的异常作为入参传递给回调方法
        CompletableFuture<Double> cf2= cf.exceptionally((param)->{
            System.out.println("error");
            System.out.println(Thread.currentThread()+" start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println("error stack trace->");
            param.printStackTrace();
            System.out.println(Thread.currentThread()+" exit,time->"+System.currentTimeMillis());
            return -1.1;
        });

        System.out.println("main thread start,time->"+System.currentTimeMillis());
        //等待子任务执行完成,此处无论是job2和job3都可以实现job2退出，主线程才退出，如果是cf，则主线程不会等待job2执行完成自动退出了
        //cf2.get时，没有异常，但是依然有返回值，就是cf的返回值
        System.out.println("run result->"+cf2.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }
  • 1. cf执行异常时，将抛出的异常作为入参传递给回调方法
  • 2. cf2.get时，没有异常，但是依然有返回值，就是cf的返回值
3.4 whenComplete
 @Test
    public void test10() throws Exception {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+"job1 start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(true){
                throw new RuntimeException("test");
            }else{
                System.out.println(Thread.currentThread()+"job1 exit,time->"+System.currentTimeMillis());
                return 1.2;
            }
        });
        //cf执行完成后会将执行结果和执行过程中抛出的异常传入回调方法，如果是正常执行的则传入的异常为null
        CompletableFuture<Double> cf2=cf.whenComplete((a,b)->{
            System.out.println(Thread.currentThread()+"job2 start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(b!=null){
                System.out.println("error stack trace->");
                b.printStackTrace();
            }else{
                System.out.println("run succ,result->"+a);
            }
            System.out.println(Thread.currentThread()+"job2 exit,time->"+System.currentTimeMillis());
        });
        //等待子任务执行完成
        System.out.println("main thread start wait,time->"+System.currentTimeMillis());
        //如果cf是正常执行的，cf2.get的结果就是cf执行的结果
        //如果cf是执行异常，则cf2.get会抛出异常
        System.out.println("run result->"+cf2.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }
  • 1. cf执行完成后会将执行结果和执行过程中抛出的异常传入回调方法，如果是正常执行的则传入的异常为null
  • 2. 如果cf是正常执行的，cf2.get的结果就是cf执行的结果
  • 3. 如果cf是执行异常，则cf2.get会抛出异常
3.5 handle
@Test
    public void test11() throws Exception {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+"job1 start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(false){
                throw new RuntimeException("test");
            }else{
                System.out.println(Thread.currentThread()+"job1 exit,time->"+System.currentTimeMillis());
                return 1.2;
            }
        });
        //cf执行完成后会将执行结果和执行过程中抛出的异常传入回调方法，如果是正常执行的则传入的异常为null
        CompletableFuture<String> cf2=cf.handle((a,b)->{
            System.out.println(Thread.currentThread()+"job2 start,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            if(b!=null){
                System.out.println("error stack trace->");
                b.printStackTrace();
            }else{
                System.out.println("run succ,result->"+a);
            }
            System.out.println(Thread.currentThread()+"job2 exit,time->"+System.currentTimeMillis());
            if(b!=null){
                return "run error";
            }else{
                return "run succ";
            }
        });
        //等待子任务执行完成
        System.out.println("main thread start wait,time->"+System.currentTimeMillis());
        //get的结果是cf2的返回值，跟cf没关系了
        System.out.println("run result->"+cf2.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }
  • 1. cf执行完成后会将执行结果和执行过程中抛出的异常传入回调方法，如果是正常执行的则传入的异常为null
  • 2. handle有返回值, get的结果是cf2的返回值，跟cf没关系了
3.6 thenCombine,thenAcceptBoth,runAfterBoth

这三个方法都是将两个CompletableFuture组合起来,都完成了才会进行下一步,三种不同方式的结合,有入参有返回值,有入参无返回值,无如参无返回值

@Test
    public void test7() throws Exception {
        ForkJoinPool pool=new ForkJoinPool();
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        });
        CompletableFuture<Double> cf2 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return 3.2;
        });
        //cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,且有返回值
        CompletableFuture<Double> cf3=cf.thenCombine(cf2,(a,b)->{
            System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
            System.out.println("job3 param a->"+a+",b->"+b);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
            return a+b;
        });

        //cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,无返回值
        CompletableFuture cf4=cf.thenAcceptBoth(cf2,(a,b)->{
            System.out.println(Thread.currentThread()+" start job4,time->"+System.currentTimeMillis());
            System.out.println("job4 param a->"+a+",b->"+b);
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job4,time->"+System.currentTimeMillis());
        });

        //cf4和cf3都执行完成后，执行cf5，无入参，无返回值
        CompletableFuture cf5=cf4.runAfterBoth(cf3,()->{
            System.out.println(Thread.currentThread()+" start job5,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.println("cf5 do something");
            System.out.println(Thread.currentThread()+" exit job5,time->"+System.currentTimeMillis());
        });

        System.out.println("main thread start cf.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("cf run result->"+cf.get());
        System.out.println("main thread start cf5.get(),time->"+System.currentTimeMillis());
        System.out.println("cf5 run result->"+cf5.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }
  • 1. thenCombine cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,且有返回值
  • 2. thenAcceptBoth cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,无返回值
  • 3. runAfterBoth cf4和cf3都执行完成后，执行cf5，无入参，无返回值
3.7 applyToEither,acceptEither,runAfterEither

这三个方法都是将两个CompletableFuture组合起来,只要其中一个执行完了就会执行某个任务,三种不同方式的结合,有入参有返回值,有入参无返回值,无如参无返回值

 @Test
    public void test8() throws Exception {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        });
        CompletableFuture<Double> cf2 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return 3.2;
        });
        //cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,且有返回值
        CompletableFuture<Double> cf3=cf.applyToEither(cf2,(result)->{
            System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
            System.out.println("job3 param result->"+result);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
            return result;
        });

        //cf和cf2的异步任务都执行完成后，会将其执行结果作为方法入参传递给cf3,无返回值
        CompletableFuture cf4=cf.acceptEither(cf2,(result)->{
            System.out.println(Thread.currentThread()+" start job4,time->"+System.currentTimeMillis());
            System.out.println("job4 param result->"+result);
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job4,time->"+System.currentTimeMillis());
        });

        //cf4和cf3都执行完成后，执行cf5，无入参，无返回值
        CompletableFuture cf5=cf4.runAfterEither(cf3,()->{
            System.out.println(Thread.currentThread()+" start job5,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.println("cf5 do something");
            System.out.println(Thread.currentThread()+" exit job5,time->"+System.currentTimeMillis());
        });

        System.out.println("main thread start cf.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("cf run result->"+cf.get());
        System.out.println("main thread start cf5.get(),time->"+System.currentTimeMillis());
        System.out.println("cf5 run result->"+cf5.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }
  • 区别在于applyToEither会将已经执行完成的任务的执行结果作为方法入参，并有返回值；
  • acceptEither同样将已经执行完成的任务的执行结果作为方法入参，但是没有返回值；
  • runAfterEither没有方法入参，也没有返回值。注意两个任务中只要有一个执行异常，则将该异常信息作为指定任务的执行结果
3.8 thenCompose

thenCompose方法会在某个任务执行完成后，将该任务的执行结果作为方法入参然后执行指定的方法，该方法会返回一个新的CompletableFuture实例，如果该CompletableFuture实例的result不为null，则返回一个基于该result的新的CompletableFuture实例；

 @Test
    public void test9() throws Exception {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        });
        CompletableFuture<String> cf2= cf.thenCompose((param)->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return CompletableFuture.supplyAsync(()->{
                System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                }
                System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
                return "job3 test";
            });
        });
        System.out.println("main thread start cf.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("cf run result->"+cf.get());
        System.out.println("main thread start cf2.get(),time->"+System.currentTimeMillis());
        System.out.println("cf2 run result->"+cf2.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }
3.9 allOf/anyOf
 @Test
    public void test12() throws Exception {
        // 创建异步执行任务:
        CompletableFuture<Double> cf = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job1,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job1,time->"+System.currentTimeMillis());
            return 1.2;
        });
        CompletableFuture<Double> cf2 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job2,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread()+" exit job2,time->"+System.currentTimeMillis());
            return 3.2;
        });
        CompletableFuture<Double> cf3 = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread()+" start job3,time->"+System.currentTimeMillis());
            try {
                Thread.sleep(1300);
            } catch (InterruptedException e) {
            }
//            throw new RuntimeException("test");
            System.out.println(Thread.currentThread()+" exit job3,time->"+System.currentTimeMillis());
            return 2.2;
        });
        //allof等待所有任务执行完成才执行cf4，如果有一个任务异常终止，则cf4.get时会抛出异常，都是正常执行，cf4.get返回null
        //anyOf是只有一个任务执行完成，无论是正常执行或者执行异常，都会执行cf4，cf4.get的结果就是已执行完成的任务的执行结果
        CompletableFuture cf4=CompletableFuture.allOf(cf,cf2,cf3).whenComplete((a,b)->{
            if(b!=null){
                System.out.println("error stack trace->");
                b.printStackTrace();
            }else{
                System.out.println("run succ,result->"+a);
            }
        });

        System.out.println("main thread start cf4.get(),time->"+System.currentTimeMillis());
        //等待子任务执行完成
        System.out.println("cf4 run result->"+cf4.get());
        System.out.println("main thread exit,time->"+System.currentTimeMillis());
    }
  • 1. allof等待所有任务执行完成才执行cf4，如果有一个任务异常终止，则cf4.get时会抛出异常，都是正常执行，cf4.get返回null
  • 2. anyOf是只有一个任务执行完成，无论是正常执行或者执行异常，都会执行cf4，cf4.get的结果就是已执行完成的任务的执行结果
ktoking
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java组合式异步编程CompletableFuture.pdf
04-16
为了应对这一挑战，Java 8引入了`CompletableFuture`，这是一种功能强大的异步编程工具，旨在简化并发编程中的复杂性，提高程序的响应能力和吞吐量。 #### 二、基础知识 `CompletableFuture`是Java 8中新增的功能之...
20个实例玩转 Java 8 异步神器 CompletableFuture.pdf
11-18
Java 8 引入的 CompletableFuture 是一种强大的工具，用于处理异步编程和构建复杂的异步计算流程。它实现了 CompletionStage 接口，这个接口定义了一种计算阶段，该阶段可以同步或异步地完成，并且可以与其他阶段...
异步执行由于主线程提前结束导致异步线程提前终止
qq_42055104的博客
01-05 1877
springboot异步任务由于主线程结束而提前终止
java8 线程 怎么退出,如何在Java 8中使用CompletableFuture启动异步任务并使主线程完成并退出...
weixin_42303522的博客
02-28 458
I have the following code (more or less):ExecutorService executor = Executors.newFixedThreadPool(10);CompletableFuture.supplyAsync(()->{return longRunningMethodThatReturnsBoolean();}, executor).the...
深入解析CompletableFuture的功能和用法
最新发布
lgq2016的博客
06-19 244
是 Java 8 中引入的一个类，它实现了接口，提供了一组丰富的方法来处理异步操作和多个任务的结果。它支持链式操作，可以方便地处理任务的依赖关系和结果转换。相比于传统的Future接口，更加灵活和强大。我们还可以通过指定自定义线程池来创建 CompletableFuture 对象，以满足特定的并发需求。() ->{ // 执行任务的代码 },在上述示例中，我们通过创建了一个固定大小为 10 的自定义线程池，并将其传递给方法来执行异步任务。
CompletableFuture
wyaoyao93的博客
04-27 240
文章目录1 介绍2 CompletableFuture的快速入门2.1 当作Future使用2.2 任务的异步运行2.2.1 异步执行Supplier类型的任务2.2.2 异步执行Runnable类型的任务2.3 异步任务链2.3.1 thenApply: 以同步的方式继续处理上一个异步任务的结果2.3.2 thenApplyAsync：以异步的方式继续处理上一个异步任务的结果。2.3.3 thenAcceptAsync：以异步的方式消费上一个异步任务的结果。2.3.4 thenRun：以同步的方式执行Ru
java开启future,Java CompletableFuture的使用详解
weixin_42513215的博客
03-22 528
CompletableFuture​它代表某个同步或异步计算的一个阶段。你可以把它理解为是一个为了产生有价值最终结果的计算的流水线上的一个单元。这意味着多个指令可以链接起来从而一个阶段的完成可以触发下一个阶段的执行。任务开启supplyAsync 开启一个子线程去执行有返回结果开启一个子线程用来执行执行事务,可以通过返回值的join来得到返回值.例如:print("去煮饭了");Completab...
CompletableFuture初学使用(会随主线程结束, 无法执行完成代码)
weixin_52408571的博客
11-22 1658
completablefutrue使用
Java并发 CompletableFuture异步编程的实现
08-25
在 Java 中，CompletableFuture 是一种异步编程的实现方式，它可以帮助开发者轻松地实现异步操作。CompletableFuture 的核心优势在于它可以将串行操作变成并行操作，从而提高性能。 异步化是并行方案得以实施的基础...
Java8 CompletableFuture详解
09-04
Java 8 的 `CompletableFuture` 是对传统 `Future` 接口的重要扩展，它引入了丰富的功能，使得异步编程和事件驱动模型更加便捷。`CompletableFuture` 不仅集成了 Guava 的 `ListenableFuture` 和 `SettableFuture` ...
java异步编程详解
08-26
Java异步编程是Java编程语言中的一种编程模型，它允许程序异步地执行任务，以提高程序的性能和响应速度。在Java中，异步编程可以通过多种方式实现，包括使用Future、Callable、Runnable、Thread、ExecutorService等...
CompletableFuture多任务执行及简单使用场景
来都来了
06-30 4850
CompletableFuture多任务执行
Future接口的cancel方法 无法正常取消正在执行的线程
weixin_34309435的博客
11-28 7277
为什么80%的码农都做不了架构师？>>> ...
使用CompletableFuture在JAVA中进行异步多线程业务处理
玩火的稻草人的博客
08-10 1021
CompletableFuture是java1.8中追加的新功能，在处理java多线程异步时相当的方便，下面是简单的用法 简单的讲述了在非主线程中，执行完一个业务后接着执行另外一个业务的处理方法thenApplyAsync。 import java.util.concurrent.CompletableFuture; public void testCompletableFuture() throws InterruptedException { // 第一个任务:
Java并发编程之CompletableFuture详解
FlyingFish868的博客
09-22 3928
在项目中经常会使用到CompletableFuture ，很多开源框架中也大量使用到了 CompletableFuture 。因此，专门写一篇文章来介绍这个 Java 8 才被引入的一个非常有用的用于异步编程的类。CompletableFuture 同时实现了 Future 和 CompletionStage 接口。
线程池、CompletableFuture
m0_38140207的博客
08-07 727
1. 线程池 1.1 线程池创建 1.2 核心线程池的内部实现 (1) 内部实现 public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
CompletableFuture使用详解,多线程相关
喜欢分享,善于记录工作中遇到的问题,和自己的思考
06-02 672
带apply表示运用,有参,有返回值带accept表示接受,有参,无返回值带Async表示异步，会另起线程，可以自定义线程池，否则用默认线程池ForkJoinPool.commonPool()该类用于对异步方法进行编排,即对多个异步任务 顺序执行、并列执行、条件执行（两者都成功再执行，两者成功一个就执行）细节,请看原文,此处只记录下主要使用方法和功能。
java异步调用CompletableFuture的使用
09-01
Java异步调用CompletableFuture是一种非常强大的工具，它可以帮助我们处理异步编程的复杂性。下面是一个简单的示例，展示了CompletableFuture的基本用法： ```java import java.util.concurrent.CompletableFuture;...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值