异步任务——CompletabelFuture

最新推荐文章于 2024-03-28 22:45:21 发布
最新推荐文章于 2024-03-28 22:45:21 发布
阅读量745 收藏 3
点赞数 1
分类专栏： 小黄重学JUC 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yellow_Star___/article/details/131811992
版权

本专栏学习内容又是来自尚硅谷周阳老师的视频

有兴趣的小伙伴可以点击视频地址观看

在学习CompletableFuture之前，必须要先了解一下Future

Future

概念

Future接口（FutureTask实现类）定义了操作异步任务执行的一些方法，如获取异步任务的执行结果、取消任务的执行、判断任务是否被取消、判断任务执行是否完毕等。

比如主线程在执行多个任务时，其中有一个任务耗时特别久，可以交给子线程执行，主线程继续做自己的事情，过一会再去获取子任务的执行结果。

FutureTask

FutureTask是Future的一个实现类

引出FutureTask

Future提供了一种异步并行计算的功能，目的是：异步多线程任务执行且返回有结果，三个特点

  • 多线程
  • 有返回
  • 异步任务

说句题外话，小黄一直不了解多线程和异步有什么区别，刚好问了ChatGpt

多线程和异步是两个相关但又不完全相同的概念。

多线程指的是在一个程序中同时运行多个线程，每个线程都是独立执行的。多线程可以使程序具有并发性，提高系统的吞吐量和响应速度。通过多线程，可以将耗时的操作和任务分配给不同的线程来执行，从而提高整体的工作效率。

异步指的是一种编程模型，其中任务的执行不需要等待前一个任务的完成。在异步编程中，可以执行一个任务，而不需要阻塞等待其完成，而是继续执行后续的任务。异步操作通常适用于涉及网络请求、文件读写、数据库查询等可能造成阻塞的操作。通过异步操作，可以充分利用等待时间来执行其他任务，提高程序的效率。

多线程和异步之间存在一定的关系。在实现异步操作时，通常会使用多线程来实现异步任务的执行。通过创建新的线程，可以在后台执行耗时的操作，而不会阻塞主线程的执行。

例如，对于一个网络请求，使用多线程可以在主线程发送请求后，继续执行其他任务，而不需要等待网络请求返回的数据。当网络请求完成后，在新的线程中处理响应数据，从而实现异步操作。

总结起来，多线程是一种实现并发性的机制，而异步是一种编程模型，在实现异步操作时通常会使用多线程来达到异步执行的效果。多线程可以提供资源的并行使用，而异步可以提高程序的运行效率和响应性。

来看一下创建线程的方式

实现Runnable接口可以开启多线程

实现Callable接口可以开启多线程并且有返回值

class MyThread1 implements Runnable {
    @Override
    public void run() {

    }
}

class MyThread2 implements Callable<String> {
    @Override
    public String call() throws Exception {
        return null;
    }
}

但是Thread的构造方法中只有参数为Runnable的方法，无法满足我们的需求

image-20230712161344204

继续往下看，发现RunnableFuture接口继承了Runnable以及Future，那也就是说他具有多线程、异步两个特点

image-20230712161533902

而FutureTask实现了RunnableFuture接口，并且他的构造方法中可以传入Callable，那么他就同时具有了多线程、异步、有返回三大特点。

image-20230712161709601

优点

Future配合线程池异步多线程，能显著提高程序的效率

需求

主线程需要执行三个任务，且三个任务耗时分别是500毫秒、300毫秒、300毫秒，如果主线程自己执行的话，那程序至少需要花费11秒的时间，现在使用Future + 线程池来优化

实现

public static void main(String[] args) throws InterruptedException {
    //创建线程池
    ExecutorService threadPool = Executors.newFixedThreadPool(3);
    long startTime = new Date().getTime();
    //创建任务
    FutureTask<String> task1 = new FutureTask<>(() -> {
        Thread.sleep(500);
        return "task1 over";
    });
    threadPool.submit(task1,"t1");

    FutureTask<String> task2 = new FutureTask<>(() -> {
        Thread.sleep(300);
        return "task2 over";
    });
    threadPool.submit(task2,"t2");

    Thread.sleep(300);
    System.out.println("task3 over");
    long endTime = new Date().getTime();
    System.out.println("花费" + (endTime - startTime) + "毫秒");  //花费338毫秒
}

缺点

get方法会阻塞

调用task1.get()会使主线程阻塞，因为get()他会一直等待子线程返回结果在继续运行。

public static void main(String[] args) throws ExecutionException, InterruptedException {
    //创建任务
    FutureTask<String> task1 = new FutureTask<>(() -> {
        Thread.sleep(5000);
        return "task1 over";
    });
    new Thread(task1,"t1").start();
    System.out.println("t1线程结果：" + task1.get());
    System.out.println("主线程执行完毕");
}

isDone方法轮询

对于上述代码，没有一个友好的提示，导致我们不知道程序为何阻塞，FutureTask提供了isDone()，调用该方法，结果为true表示线程执行完毕。

但是这种方法的结果就是需要不停的轮询，大量的消耗了CPU

public static void main(String[] args) throws ExecutionException, InterruptedException {
    //创建任务
    FutureTask<String> task1 = new FutureTask<>(() -> {
        Thread.sleep(5000);
        return "task1 over";
    });
    new Thread(task1,"t1").start();

    while (true) {
        if (task1.isDone()) {
            System.out.println("t1线程结果：" + task1.get());
            break;
        }else {
            Thread.sleep(500);
            System.out.println("请等待");
        }
    }
    System.out.println("主线程执行完毕");
}

更复杂的任务

对于简单的任务使用Future完全可以解决，下面有几个更为复杂的需求Future不好解决了

  • 多个任务前后可以组合处理

    例如：子线程A计算返回的结果，在子线程B中需要用到

  • 对计算速度选最快

    例如：联机游戏，谁先到终点谁就赢了，那么当A到达终点时，B的线程也需要中断

对此，就引出了CompletableFuture，这就有点像一个名场面东厂管不了的，我西厂来管，东厂管得了的，我西厂更要管，也就是说Future有的功能CompletableFuture都有，Future没有的功能CompletableFuture也有，有点像plus版本。

CompletableFuture

之前介绍了Future，发现他只能解决一些简单的逻辑，并且阻塞的方式和异步编程的设计理念相违背，而轮询的方式会消耗无谓的CPU资源，所有CompletableFuture应运而生。

概念

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

他是JDK1.8新增的类，实现了Future、CompletionStage接口

Future不用在介绍了，CompletionStage提供了一种处理异步操作结果的机制，可以与回调函数一起使用，来处理 CompletableFuture 的计算结果。

image-20230713151615088

创建方式

我们学习一个新的类的方式，第一步就是看他的构造函数，创建这个类，CompletableFuture虽然有一个空参构造函数，但是官方并不推荐我们使用，一般我们通过4个静态方法来创建。

调用静态方法创建返回值
CompletableFuture runAsync(Runnable runnable)无
CompletableFuture runAsync(Runnable runnable,Executor executor)无
CompletableFuture supplyAsync(Supplier supplier)有
supplyAsync(Supplier supplier, Executor executor)有

代码实现

runAsync()

不带有线程池，默认使用ForkJoinPool的线程

public static void main(String[] args) throws ExecutionException, InterruptedException {
    CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
        System.out.println("进入子线程:" + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    });

    System.out.println(completableFuture.get()); //null
    System.out.println("主线程结束");
}

supplyAsync

public static void main(String[] args) throws ExecutionException, InterruptedException {
    CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
        System.out.println("进入子线程:" + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        int result = ThreadLocalRandom.current().nextInt(10);
        System.out.println("子线程执行结果:" + result);
        return result;
    });

    System.out.println(completableFuture.get());
    System.out.println("主线程结束");
}

带有线程池的创建就不举例了

通用异步编程

上面还是在演示Future原有的功能，接下来学一下新的功能

通过whenComplete来监听子进程执行完毕，来做一系列操作

通过exceptionally来解决子进程出现异常的情况

public static void main(String[] args) throws ExecutionException, InterruptedException {
    CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
        System.out.println("进入子线程:" + Thread.currentThread().getName());
        System.out.println(Thread.currentThread().isDaemon()); //守护线程
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        int result = ThreadLocalRandom.current().nextInt(10);
        System.out.println("子线程执行结果:" + result);
        return result;
    }).whenComplete((v,e) -> {
        if (e == null) {
            System.out.println("计算结果为：" + v);
        }
    }).exceptionally(e -> {
        //处理异常
        e.printStackTrace();
        System.out.println("计算过程出现异常：" + e.getCause() + "\t" + e.getMessage());
        return null;
    });
    System.out.println("主线程结束");
}

//输出
进入子线程:ForkJoinPool.commonPool-worker-9
主线程结束

但是发现控制台输出没有等待结果，主线程就直接结束了，这是因为默认情况下ForkJoinPool里面是守护线程，解决方法有两种

  1. 在主线程结束前等待
  2. 使用自定义的线程池

修改代码

public static void main(String[] args) throws ExecutionException, InterruptedException {
    ExecutorService threadPool = Executors.newFixedThreadPool(10);

    CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
        System.out.println("进入子线程:" + Thread.currentThread().getName());
        System.out.println(Thread.currentThread().isDaemon()); //守护线程
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        int result = ThreadLocalRandom.current().nextInt(10);
        System.out.println("子线程执行结果:" + result);
        return result;
    },threadPool).whenComplete((v,e) -> {
        if (e == null) {
            System.out.println("计算结果为：" + v);
        }
    }).exceptionally(e -> {
        //处理异常
        e.printStackTrace();
        System.out.println("计算过程出现异常：" + e.getCause() + "\t" + e.getMessage());
        return null;
    });
    System.out.println("主线程结束");
    threadPool.shutdown();
}

//输出
进入子线程:pool-1-thread-1
false
主线程结束
子线程执行结果:7
计算结果为：7

通过控制台输出可以看到，自定义线程池创建的是用户线程，所以即使是主线程执行完毕，程序还是要等待所有用户线程执行完毕才会结束。

链式语法

接下来会用到很多链式语法，这个在Java8很常见，其实就是在写法上更加简洁了

public class CompletableFutureDemo5 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Student student = new Student();
        /*
        以前的写法
        student.setId(1);
        student.setName("张三"));
         */
        student.setId(1).setName("张三");
        System.out.println(student);
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
class Student{
    private Integer id;
    private String name;
}

join方法

在介绍join()之前，必须先介绍一下get()

get()是获取异步计算结果，但是在编译期会需要抛出异常

image-20230718150444583

join()也是获取异步计算结果，但是不需要抛出异常

image-20230718150548558

电商比价案例

需求：

需要查询《深入理解JVM虚拟机》这本书在各大电商平台销售的价格，显示结果如下

《深入理解JVM虚拟机》in jd price is 100

普通解决方案

使用同步方式，一步一步来，查一个保存一个价格

此方法的优点是简洁粗暴，缺点是非常的耗时

public class CompletableFutureDemo7 {
    static List<NetMall> malls = Arrays.asList(
            new NetMall("jd"),
            new NetMall("tb"),
            new NetMall("pdd")
    );

    public static List<String> step(List<NetMall> list ,String productName){
        return list.stream()
                .map(netMall -> String.format(productName + " in %s price is %.2f",
                        netMall.getNetMallName(),
                        netMall.calcPrice(productName)))
                .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        long startTime = new Date().getTime();
        List<String> list = step(malls, "MySQL");
        long endTime = new Date().getTime();
        System.out.println("耗时：" + (endTime - startTime));
        for (String item : list) {
            System.out.println(item);
        }
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class NetMall{
    private String netMallName;

    public double calcPrice(String productName) {
        //模拟请求过程耗时
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        return ThreadLocalRandom.current().nextDouble() * 2 + productName.charAt(0);
    }
}

//结果
耗时：3067
MySQL in jd price is 78.86
MySQL in tb price is 78.95
MySQL in pdd price is 78.98

异步解决方案

核心计算方法，使用异步的方式进行，这样大大的节约了时间

public static List<String> byCompletableFuture(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))))
            .collect(Collectors.toList())
            .stream()
            .map(s -> s.join())
            .collect(Collectors.toList());
}

//结果
耗时：1050
MySQL in jd price is 77.77
MySQL in tb price is 77.18
MySQL in pdd price is 77.32

计算方法

CompletableFuture提供了非常多的计算方法

获取结果和触发计算

方法名作用
public T get()获取结果，会造成当前线程阻塞
public T get(long timeout, TimeUnit unit)获取结果，在指定的时间内获取不到，抛出异常
public T join()获取结果，跟get()用法一致，区别是编译器不需要抛异常
public T getNow(T valueIfAbsent)立刻获取结果，如果结果没出来，使用指定值代替结果
public boolean complete(T value)中断计算，计算过程被中断返回true，并且用指定值代替计算结果
public static void main(String[] args) throws InterruptedException {
    CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        return "123";
    });
    TimeUnit.SECONDS.sleep(2);
    System.out.println(completableFuture.complete("completeValue") + "\t " + completableFuture.join());//true	 completeValue
}

对计算结果进行处理

方法名作用
public CompletableFuture thenApply()获取计算结果，对其进行处理
public CompletableFuture handle()作用同thenApply，区别在于遇到异常不会组织下一步运行

thenApply()

public class CompletableFutureDemo9 {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService threadPool = Executors.newFixedThreadPool(10);

        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("111");
            return 1;
        },threadPool).thenApply(f -> {
            System.out.println("222");
            return f + 1;
        }).thenApply(f -> {
            System.out.println("333");
            return f + 2;
        }).whenComplete((v,e) -> {
            if (e == null) {
                System.out.println("计算结果：" + v);
            }
        }).exceptionally(e -> {
            e.printStackTrace();
            return null;
        });

        System.out.println("主线程去忙其他的了 ： " + Thread.currentThread().getName());
        threadPool.shutdown();
    }
}

可以看到程序在抛异常时，就停止了，不会继续往下执行

image-20230719135405676

hanlde()

public static void main(String[] args) throws InterruptedException {
    ExecutorService threadPool = Executors.newFixedThreadPool(10);

    CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("111");
        return 1;
    }, threadPool).handle((f, e) -> {
        int i = 1 / 0;
        System.out.println("222");
        return f + 1;
    }).handle((f, e) -> {
        System.out.println("333");
        return f + 2;
    }).whenComplete((v, e) -> {
        if (e == null) {
            System.out.println("计算结果：" + v);
        }
    }).exceptionally(e -> {
        e.printStackTrace();
        return null;
    });

    System.out.println("主线程去忙其他的了 ： " + Thread.currentThread().getName());
    threadPool.shutdown();
}

通过输出可以看出在第一个handle中出现异常，不继续往下执行该handle的方法，但是不影响后续的hanlde方法

image-20230719135510783

对计算结果进行消费

消费，顾名思义就是把这条消息消费掉，后面的人就获取不到这条消息了。

方法作用
public CompletableFuture thenRun(Runnable action)任务A执行完执行B，并且B不需要A的结果
public CompletableFuture thenAccept(Consumer<? super T> action)任务A执行完执行B，B需要A的结果，但是任务B没有返回值
public CompletableFuture thenApply任务A执行完执行B，B需要A的结果，同事任务B有返回值

如下所示，thenAccept()方法，在获取结果时为null

public static void main(String[] args) throws InterruptedException {
    System.out.println(CompletableFuture.supplyAsync(() -> "resultA").thenRun(() -> {}).join()); //null
    System.out.println(CompletableFuture.supplyAsync(() -> "resultB").thenAccept(y -> {System.out.println(y);}).join()); //resultB  null
    System.out.println(CompletableFuture.supplyAsync(() -> "resultC").thenApply(y -> y + "resultD").join()); //resultCresultD
}

对运行线程池进行选择

不使用线程池，默认走的是ForkJoinPool

image-20230719155843600

使用线程池，走的全都是自定义线程池

image-20230719160752242

使用线程池，中间调用了thenRunAsync方法，那么之后的方法都会使用ForkJoinPool

image-20230719160832347

源码

thenRun()和thenRunAsync()区别在于一个传参使用了默认的线程池

image-20230719161125302

image-20230719161136157

对计算速度进行选用

调用applyToEither()方法，他会将两个异步任务先完成的值返回

public class CompletableFutureDemo12 {
    public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {throw new RuntimeException(e);}
            return "future1";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {throw new RuntimeException(e);}
            return "future2";
        });

        CompletableFuture<String> result = future1.applyToEither(future2, s ->  s + " is win");
        System.out.println(result.join()); //future1 is win
    }
}

对计算结果进行合并

thenCombine()可以将两个计算结果合并

public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {throw new RuntimeException(e);}
        return 10;
    });

    CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
        try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {throw new RuntimeException(e);}
        return 20;
    });

    CompletableFuture<Integer> result = future1.thenCombine(future2, (x,y) -> {
        System.out.println("计算结果合并");
        return x + y;
    });
    System.out.println(result.join()); //30
}
贼爱学习的小黄
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程之定时任务 以及 SpringBoot多线程实现定时任务——异步任务
03-12
1. SpringBoot 自定义线程池以及多线程间的异步调用（@Async、@EnableAsync） 2.Java多线程之定时任务 以及 SpringBoot多线程实现定时任务 3.@EnableScheduling 与 @Scheduled
SpringBoot异步任务使用方法详解
08-19
SpringBoot异步任务使用方法详解 SpringBoot异步任务使用方法详解是基于Java的SpringBoot框架中的一种异步任务处理机制。该机制允许开发者在SpringBoot应用程序中执行异步任务，以提高应用程序的性能和响应速度。 ...
CompletableFuture 执行异步任务
weixin_46685542的博客
10-11 1902
CompletableFuture 执行异步任务
CompletableFuture实现异步任务
花开半夏 · 流年似水
02-01 2210
CompletableFuture 是 Future API的扩展。 Future 被用于作为一个异步计算结果的引用。提供一个 isDone() 方法来检查计算任务是否完成。当任务完成时，get() 方法用来接收计算任务的结果。 项目需求： 项目中需要优化一个接口，这个接口需要拉取2，3个第三方接口，需求延迟时间小于200ms; 技术选型： 在Java中CompletableFuture用于异步编程，异步编程是编写非阻塞的代码，运行的任务在一个单独的线程，与主线程隔离，并且会通知主线程它的进度，成功或者失败
强大的CompletableFuture开启异步执行任务
wangfenglei123456的博客
02-08 973
本文介绍CompletableFuture类，开启线程异步执行任务。 参考视频：这个视频讲的很好，一定要去看。。。。。。 【Java并发·03】CompletableFuture入门_哔哩哔哩_bilibili异步编程，原来可以这样简单多线程、异步 是近些年来工作中越来越常用的技术但是有好多同学都停留在 Thread 层面，没有去了解更方便的工具这是制作视屏以来的第三个作品，加入了一些搞笑的元素。希望能让你们轻轻松松学知识-本节课是 CompletableFuture 的入门课讲到了 Completab
使用CompletableFuture异步执行数据处理
qq_42863863的博客
03-15 529
使用CompletableFuture异步执行数据处理
Java并发编程: 第九章 CompletableFuture异步编程
最新发布
玉汝于成
03-28 453
CompletableFuture 提供了一种函数式编程的方式来处理异步计算的结果，允许你以非阻塞的方式组合和链接异步操作。例如，你可以使用 thenApply 来转换异步操作的结果，使用 thenCompose 来链接多个异步操作，或者使用 allOf 和 anyOf 来等待多个 CompletableFuture 完成。使用 CompletableFuture，你可以轻松地将多个异步操作组合成一个链式调用，并在每个异步操作完成后执行某些操作（比如转换结果、组合多个结果、处理异常等）。
Django异步任务线程池实现原理
09-18
主要介绍了Django异步任务线程池实现原理,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
加强版异步任务框架
01-27
加强版异步任务框架是为了优化Android应用的性能和用户体验，将耗时操作移至后台线程，避免阻塞主线程。传统的解决方案如AsyncTask虽然简洁易用，但存在内存泄漏和不适合长时间任务的问题。本文介绍的加强版异步任务...
C#异步执行任务的方法
09-03
在C#编程中，异步执行任务是一种提升应用程序性能的关键技术。它允许代码在等待某个操作完成时继续执行其他任务，而不是阻塞当前线程，从而提高了系统的响应性和效率。本篇文章将深入探讨C#中异步执行任务的方法，并...
Springboot利用CompletableFuture异步执行线程（有回调和无回调）
weixin_42966151的博客
10-12 4514
项目中总会有需要异步执行来避免浪费时间资源的情况，这就需要异步操作。异步又分两种： 1、无回调：有一些执行过程对用户而言不需要反馈回调，只需要自己执行即可，且执行过程时间较长（某些第三方接口，如发送短信验证码、查取ip属地等等），如果同步执行，势必会影响到用户体验，这时候就可以使用CompletableFuture.runAsync()方法了。 2、有回调：在执行异步操作结束后，需要获得异步方法返回的值，然后再回调给用户展示，这时候就需要用到CompletableFuture.supplyAsync()
CompletableFuture异步任务的简单使用
持续Java学习中
12-04 1245
文章目录一、FutureTask1、Runnable接口2、Callable接口3、Future接口4、代码测试案例5、总结二、CompletionService1、代码测试案例2、源码实现原理三、CompletableFuture1、API描述2、API补充细节说明3、异步任务代码测试（必看） 写在前面：如果你是奔着标题来的，只想看CompletableFuture的使用，可以直接拉到第三节，查看具体的测试案例。如果你是想由浅入深的学习，建议按照顺序一点一点往下看 一、FutureTask 1、Ru
Java并发编程—CompletableFuture的异步执行案例
小魏快起床的博客
12-06 1100
临近过年了，很多铁子都有购物的需求，那么大家肯定想花更少的钱去买相同的一个产品，例如茅台酒在不同的购物平台或者不同的商家里面价格是不一样的，例如：🍕jd：🍕tb： 图中这些价格都是不一样的，所以大家就会有一个需求，能不能把这个当作一个程序进行一个数据统计，统计出不同平台的茅台价格，然后自己根据价格、商家来购买，这个例子大家都明白，其实在工作中也有很多这种的需求，那么针对这种需要统计的需求业务我们该怎么去做呢？ 相信很多铁子有心里有方案： 🍄2、业务开始前还需要实例化几个具
CompletableFuture执行异步操作的几种方法
betterandbetteryw的博客
10-23 256
与supplyAsync()不同的是，runAsync()传入的任务要求是Runnable类型的，所以没有返回值。因此，runAsync适合创建不需要返回值的计算任务。CompletableFuture.supplyAsync()也可以用来创建CompletableFuture实例。由于新创建的CompletableFuture还没有任何计算结果，这时调用join，当前线程会一直阻塞在这里。此时，如果在另外一个线程中，主动设置该CompletableFuture的值，则上面线程中的结果就能返回。
CompletableFuture 异步多线程使用方法
卓越之识论道，平常之识论事，狭隘之识论人
08-08 2352
CompletableFuture使用教程
CompletableFuture异步多任务最佳实践
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
12-10 3792
Java并发编程实战》一书中，Brian Goetz和合著者们为线程池大小的优化提供了不少中肯的建议。这非常重要，如果线程池中线程的数量过多，最终它们会竞争稀缺的处理器和内存资源，浪费大量的时间在上下文切换上。反之，如果线程的数目过少，正如你的应用所面临的 情况，处理器的一些核可能就无法充分利用。
CompletableFuture 批量异步请求、合并请求实现
zhaoyang10的专栏
12-19 3697
public static void test() { AtomicInteger total = new AtomicInteger(); List<Long> testList = new ArrayList<>(); for (int i = 0; i < 22; i++) { testList.add(Lon...
CompletableFuture批量执行异步任务
lhc66666的博客
03-01 379
CompletableFuture批量执行异步任务
CompletableFuture的异步批量
weixin_42391501的博客
06-21 290
@Slf4j @SpringBootTest @RunWith(SpringRunner.class) public class TimeLimitedTransJobTest { private static ExecutorService TIME_LIMITED_SEND_BACK_THREAD_POOL = new ThreadPoolExecutor(16, 16, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue&lt.
java异步任务流式
10-12
Java中实现异步任务流式处理可以使用CompletableFuture类。该类提供了一系列方法，可以将多个异步任务串联起来，形成一个异步任务流，从而实现异步任务的流式处理。 例如，我们可以使用thenApply()方法将一个异步任务的结果传递给下一个异步任务进行处理，使用thenCompose()方法将多个异步任务组合成一个异步任务，使用thenAccept()方法在异步任务完成后执行一些操作等等。 下面是一个简单的示例代码： ``` CompletableFuture.supplyAsync(() -> "Hello") .thenApplyAsync(s -> s + " World") .thenAcceptAsync(System.out::println); ``` 在上面的代码中，我们首先创建了一个CompletableFuture对象，该对象会异步执行一个任务，返回字符串"Hello"。然后我们使用thenApplyAsync()方法将该字符串传递给下一个异步任务进行处理，该异步任务会在原字符串后面添加" World"。最后，我们使用thenAcceptAsync()方法在异步任务完成后打印结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值