CompletableFuture异步线程

最新推荐文章于 2025-06-12 18:02:14 发布
原创 最新推荐文章于 2025-06-12 18:02:14 发布 · 348 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #后端

  1. CompletableFuture使用
package com.infoextraction.controller;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import java.io.*;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

@Controller
public class HelloController {
    public static ExecutorService executor= Executors.newFixedThreadPool(10);
    private static Logger logger = LoggerFactory.getLogger(HelloController.class);
	/**
	 *
	 *异步执行无返回值
	 */
    public static void main(String[] args) {
        CompletableFuture.runAsync(()->{
            Thread.currentThread().getId();
            //代码逻辑
            int i=10/2;
            System.out.println("运行结果:"+i);
        },executor);
    }
}

  /**
     * 方法完成后返回值
     * @param args
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            Thread.currentThread().getId();
            //代码逻辑
            int i = 10 / 2;
            System.out.println("运行结果:" + i);
            return i;
        }, executor);
        Integer result = integerCompletableFuture.get();
        logger.info("处理完后返回的结果为{}",result);
    }

/**
     * 方法完成执行完成后感知
     * @param args
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            Thread.currentThread().getId();
            //代码逻辑 （如果想要测试异常处理则可以将2改为0  0不能最为除数所以会抛异常）
            int i = 10 / 2;
            System.out.println("运行结果:" + i);
            return i;
            //result 返回结果  exception 异常信息
        }, executor).whenComplete((result,exception)->{
            //whenComplete 虽然可以得到异常信息  但是无法修改返回数据
            logger.info("异步任务完成了。。结果是{},异常是{}",result,exception);
        }).exceptionally(throwable -> {
            //exceptionally 可以感知异常，同时返回默认值
            return 10;
        });
        Integer integer = integerCompletableFuture.get();
        logger.info("最终结果为{}",integer);
    }

  /**
     * 方法完成执行完成后处理 :handle无论是执行成功还是失败都可以处理
     * @param args
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
            Thread.currentThread().getId();
            //代码逻辑
            int i = 10 / 2;
            System.out.println("运行结果:" + i);
            return i;
            //result 返回结果  exception 异常信息
        }, executor).handle((result,exception)->{
            //对结果进行处理
            if(result!=null){
                //执行逻辑
                return result*2;
            }
            //对异常进行处理
            if(exception!=null){
                //处理逻辑
                return 0;
            }
            return 0;
        });
        //打印处理结果
        Integer reslut = integerCompletableFuture.get();
        logger.info("处理结果为{}",reslut);
    }

  /**
     * 线程串行化
     * @param args
     */
    public static void main(String[] args) {

        CompletableFuture<Void> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
        Thread.currentThread().getId();
        logger.info("任务A开始执行");
        //代码逻辑
        int i = 10 / 2;
        System.out.println("运行结果:" + i);
        return i;
        //thenRunAsync 任务A执行完执行任务B 但是无法获取到上一步任务A的执行结果且无返回值
        },executor).thenRunAsync(()->{
        logger.info("任务B开始执行");
        System.out.println("111");
        },executor);
    }

  /**
     * 线程串行化
     * @param args
     */
    public static void main(String[] args) {

        CompletableFuture<Void> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
        Thread.currentThread().getId();
        logger.info("任务A开始执行");
        //代码逻辑
        int i = 10 / 2;
        System.out.println("运行结果:" + i);
        return i;
        //thenAcceptAsync 任务A执行完执行任务B 可以获取到任务A的返回值但是无返回值
        },executor).thenAcceptAsync((res)->{
        logger.info("任务B开始执行,获取到任务A的返回结果为{}",res);
        logger.info("执行任务B逻辑11222233344");
        },executor);
    }

    /**
     * 线程串行化
     * @param args
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
        Thread.currentThread().getId();
        logger.info("任务A开始执行");
        //代码逻辑
        int i = 10 / 2;
        System.out.println("运行结果:" + i);
        return i;
        //thenAcceptAsync 任务A执行完执行任务B 即可以获取到上一步任务A的执行结果且有返回值
        },executor).thenApplyAsync((res)->{
        logger.info("任务B开始执行,获取到任务A的返回结果为{}",res);
        return "Hello "+res;
        },executor);
        logger.info(integerCompletableFuture.get());
    }

 /**
     * 两个任务组合
     * @param args
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> taskA = CompletableFuture.supplyAsync(() -> {
        Thread.currentThread().getId();
        logger.info("任务A开始执行");
        //代码逻辑
        int i = 10 / 2;
        System.out.println("运行结果:" + i);
        return i;
        //thenAcceptAsync 任务A执行完执行任务B 即可以获取到上一步任务A的执行结果且有返回值
        },executor);
        CompletableFuture<String> taskB = CompletableFuture.supplyAsync(() -> {
            Thread.currentThread().getId();
            logger.info("任务B开始执行");
            return "Hello";
        },executor);
        //组合任务A任务B完成后  任务A任务B组合执行后执行任务C 但是runAfterBothAsync 
        //获取不到 组合任务A任务B的执行结果
        taskA.runAfterBothAsync(taskB,()->{
            logger.info("任务C开始执行");
        });


 /**
     * 两个任务组合
     * @param args
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> taskA = CompletableFuture.supplyAsync(() -> {
        Thread.currentThread().getId();
        logger.info("任务A开始执行");
        //代码逻辑
        int i = 10 / 2;
        System.out.println("运行结果:" + i);
        return i;
        //thenAcceptAsync 任务A执行完执行任务B 即可以获取到上一步任务A的执行结果且有返回值
        },executor);
        CompletableFuture<String> taskB = CompletableFuture.supplyAsync(() -> {
            Thread.currentThread().getId();
            logger.info("任务B开始执行");
            return "Hello";
        },executor);
        //组合任务A任务B完成后  任务A任务B组合执行完成后后执行任务C thenAcceptBothAsync 
       // 且可以获取到组合任务A任务B的执行结果 但是无返回值
        taskA.thenAcceptBothAsync(taskB,(taskAResult,taskBResult)->{
            logger.info("任务A的执行结果为{},任务B的执行结果为{}",taskAResult,taskBResult);
        },executor);
    }

    CompletableFuture<Integer> taskA = CompletableFuture.supplyAsync(() -> {
        Thread.currentThread().getId();
        logger.info("任务A开始执行");
        //代码逻辑
        int i = 10 / 2;
        System.out.println("运行结果:" + i);
        return i;
        //thenAcceptAsync 任务A执行完执行任务B 即可以获取到上一步任务A的执行结果且有返回值
        },executor);
        CompletableFuture<String> taskB = CompletableFuture.supplyAsync(() -> {
            Thread.currentThread().getId();
            logger.info("任务B开始执行");
            return "Hello";
        },executor);
         //组合任务A任务B执行完成后执行任务C  thenAcceptBothAsync可以获取到自核任务A和任务B的返回值，
         //且可以返回值
        CompletableFuture<String> result = taskA.thenCombineAsync(taskB, (taskAResult, taskBResult) -> {
            logger.info("开始执行任务C");
            logger.info("任务A的执行结果为{},任务B的执行结果为{}", taskAResult, taskBResult);
            return "任务A" + taskAResult + "任务B" + taskBResult + "任务C" + "World";
        }, executor);
        logger.info("最终执行结果为{}",result.get());
    }

 /**
     * 两个任务组合
     * @param args
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Object> taskA = CompletableFuture.supplyAsync(() -> {
        Thread.currentThread().getId();
        logger.info("任务A开始执行");
        //代码逻辑
        int i = 10 / 2;
        System.out.println("运行结果:" + i);
        return i;
        //thenAcceptAsync 任务A执行完成执行任务B 即可以获取到上一步任务A的执行结果且有返回值
        },executor);
        CompletableFuture<String> taskB = CompletableFuture.supplyAsync(() -> {
            Thread.currentThread().getId();
            logger.info("任务B开始执行");
            return "Hello";
        },executor);
        //组合结果任务A任务B 只要有一个执行完成就执行任务C,但是获取不到组合结果的返回结果,且无返回值
        taskA.runAfterEitherAsync(taskB,()->{
            logger.info("任务C开始执行");
        },executor);
        //组合结果任务A任务B 只要有一个执行完成就执行任务C,可以获取到其中一个的返回结果,且无返回值
        taskA.acceptEitherAsync(taskB,(res)->{
            logger.info("任务A或者任务B的结果为{}",res);
            logger.info("任务C开始执行");
        },executor);
        //组合结果任务A任务B 只要有一个执行完成就执行任务C,可以获取到其中一个的返回结果,且有返回结果
        taskA.applyToEitherAsync(taskB,res->{
            logger.info("任务A或者任务B的结果为{}",res);
            logger.info("任务C开始执行");
            return res+"任务C结果为"+"World";
        },executor);
    }

  /**
     * 任务全部完成后返回
     * @param args
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Object> taskA = CompletableFuture.supplyAsync(() -> {
        Thread.currentThread().getId();
        logger.info("任务A开始执行");
        //代码逻辑
        int i = 10 / 2;
        System.out.println("运行结果:" + i);
        return i;
        //thenAcceptAsync 任务A执行完成执行任务B 即可以获取到上一步任务A的执行结果且有返回值
        },executor);
        CompletableFuture<String> taskB = CompletableFuture.supplyAsync(() -> {
            Thread.currentThread().getId();
            logger.info("任务B开始执行");
            return "Hello";
        },executor);
        CompletableFuture<String> taskC = CompletableFuture.supplyAsync(() -> {
            Thread.currentThread().getId();
            logger.info("任务C开始执行");
            return "World";
        },executor);

        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.allOf(taskA, taskB, taskC);
        ////阻塞  三个任务全部执行完成后返回结果
        voidCompletableFuture.get();
        logger.info("最终结果为{}",voidCompletableFuture.get());
    }

 /**
     * 任务全部完成后执行其他逻辑
     * @param args
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Object> taskA = CompletableFuture.supplyAsync(() -> {
        Thread.currentThread().getId();
        logger.info("任务A开始执行");
        //代码逻辑
        int i = 10 / 2;
        System.out.println("运行结果:" + i);
        return i;
        //thenAcceptAsync 任务A执行完成执行任务B 即可以获取到上一步任务A的执行结果且有返回值
        },executor);
        CompletableFuture<String> taskB = CompletableFuture.supplyAsync(() -> {
            Thread.currentThread().getId();
            logger.info("任务B开始执行");
            return "Hello";
        },executor);
        CompletableFuture<String> taskC = CompletableFuture.supplyAsync(() -> {
            Thread.currentThread().getId();
            logger.info("任务C开始执行");
            return "World";
        },executor);

        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.allOf(taskA, taskB, taskC);
        ////阻塞  等待所有任务全部完成
        voidCompletableFuture.get();
    }

  /**
     * 只要有一个任务完成则返回结果
     * @param args
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Object> taskA = CompletableFuture.supplyAsync(() -> {
        Thread.currentThread().getId();
        logger.info("任务A开始执行");
        //代码逻辑
        int i = 10 / 2;
        System.out.println("运行结果:" + i);
        return i;
        //thenAcceptAsync 任务A执行完成执行任务B 即可以获取到上一步任务A的执行结果且有返回值
        },executor);
        CompletableFuture<String> taskB = CompletableFuture.supplyAsync(() -> {
            Thread.currentThread().getId();
            logger.info("任务B开始执行");
            return "Hello";
        },executor);
        CompletableFuture<String> taskC = CompletableFuture.supplyAsync(() -> {
            Thread.currentThread().getId();
            logger.info("任务C开始执行");
            return "World";
        },executor);

        CompletableFuture<Object> objectCompletableFuture = CompletableFuture.anyOf(taskA, taskB, taskC);
       //只要有一个成功则返回
        objectCompletableFuture.get();
        logger.info("结果为{}", objectCompletableFuture.get());
    }
CompletableFuture(异步编程详解)
weixin_49161209的博客
09-09 1015
CompletableFuture 一、runAsync 1.1、runAsunc（一个Runnable接口） package com.thread.study.jdksyn; import java.util.concurrent.*; /** * @ClassName * @Description TODO * @Author ZQS * @Date 2020/9/9 0009 14:29 * @Version 1.0 **/ public class CompletableFuture
CompletableFuture实现异步编排
m0_71777195的博客
01-30 194
为什么需要异步执行？①获取商品基本信息 ②获取商品图片信息 ③获取商品促销活动信息 ④获取商品各种类的基本信息等操作，如果使用串行方式去执行这些操作，假设每个操作执行1s，那么用户看到完整的商品详情就需要4s的时间，如果使用并行方式执行这些操作，可能只需要1s就可以完成。所以这就是异步执行的好处。JDK5的Future接口Future接口用于代表异步计算的结果，通过Future接口提供的方法可以查看异步计算是否执行完成，或者等待执行结果并获取执行结果，同时还可以取消执行。列举Futureget()
Java8新的异步编程方式CompletableFuture实现
08-26
主要介绍了Java8新的异步编程方式CompletableFuture实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
异步编程——CompletableFuture
最新发布
qq_57019146的博客
06-12 460
是 Java 8 引入的一个强大的异步编程工具，位于包中。它是Future接口的实现类，但相比传统的Future提供了更灵活、更强大的异步任务处理能力，支持链式调用、组合多个异步任务、异常处理等功能，极大地简化了 Java 中异步编程的复杂性。
Java多线程之异步Future机制的原理和实现
09-01
主要为大家详细介绍了Java多线程之异步Future机制的原理和实现，感兴趣的小伙伴们可以参考一下
CompletableFuture异步编程
weixin_38612830的博客
08-28 533
CompletableFuture异步编程
04-CompletableFuture异步线程 性能
彼岸舞的博客
04-11 350
场景 场景 方法 任务少, 不频繁 直接使用线程 任务数稳定,频繁 使用线程池 线程池 优点 不用频繁的创建和销毁线程 不需要担心OOM 直接往任务队列添加任务即可 核心线程忙不过来,可以自动增加到最大线程数 构造参数 核心线程数 最大线程数 空闲活跃时长 时长单位 阻塞队列 线程工厂 拒绝策略 直接丢弃 替换最后一个 ...
java多线程实战二：CompletableFuture异步任务实现
蓝e的专栏
04-18 668
supplyAsync() 以Supplier函数式接口类型为参数，返回结果类型为U；Supplier接口的 get()是有返回值的，调用时会阻塞主线程。这里为了简单，直接顺序执行，没有join并行返回结果。CompletableFuture默认线程池是ForkJoinPool.commonPool()，但为了实现线程之间互不影响，且便于定位问题，强烈推荐自定义线程池。主线程中pageCompletableFuture.get()非阻塞主线程，等待异步任务返回数据。
奇淫巧技，CompletableFuture 异步多线程是真的优雅
胸纳甲兵，烽烟起可靖疆晏海。
12-13 955
一个示例回顾Future通过CompletableFuture实现上面示例CompletableFuture创建方式异步回调方法异常回调多任务组合回调CompletableFuture使用有哪些注意点。
简述CompletableFuture异步任务编排
BASK2312的博客
11-22 323
在之前的项目开发中，都没怎么使用过CompletableFuture的功能，只听说过和异步编程有关。为了能够在将来有需要的时候用得上，这两天花了点时间学习了一下，并简单地总结一下如何使用CompletableFuture完成异步任务编排。​@Override// 设置为守护线程，main线程结束就跟着一起结束，否则main函数结束jvm还在return t;}复制代码。
CompletableFuture 异步多线程使用方法
卓越之识论道，平常之识论事，狭隘之识论人
08-08 4273
CompletableFuture使用教程
CompletableFuture 异步处理
沉淀所学，分享所思，让热爱与成长同行。商务记录AI实战经验，助力开发者快速成长。 热爱AI，希望做出有影响力的技术成果。 技术点亮生活，分享连接价值与机会。 专注AI落地实战，陪你走好技术每一步。
07-16 5551
我们传统的程序都是单线程的，程序的运行是同步的。（一个执行完一个执行）比如查询A表要20秒,查询B表也要20秒那么在同步执行的情况下总共需要40秒的时间。而异步处理是将这2个查询异步的去进行，总共只需要20秒，极大的提高了系统的吞吐量。异步就是从主线程发射一个子线程来完成任务.大家对异步有一个简单认识之后；......
CompletableFuture 异步编排
老男孩的架构路
08-16 621
在 Java8 中，新增了 CompletableFuture 异步编程工具类。它与我们之前使用的 Future 接口有何区别呢？本文将对这个重要的 CompletableFuture 类进行分析学习。1、runXxx 都是没有返回结果的，supplyXxx 都是可以获取返回值的；2、可以传入自定义的线程池，否则就用默认的线程池：ForkJoinPool.commonPool()；3、Async 代表异步的意思。2.1 获得结果和触发计算获得结果get() :不见不散。...
CompletableFuture——异步编程艺术
程序员阿龙的博客
08-14 2514
CompletableFuture——异步编程艺术
CompletableFuture使用详解（全网看这一篇就行）
热门推荐
搬砖老农工的博客
04-02 10万+
CompletableFuture是jdk8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。 1. supplyAsync supplyAsync是带有返回值的异步任务。它有如下两个方法，有一个是带有线程池的重载方法 // 带返回值异步请求，默认线程池 public static <U> Completa
CompleteableFuture实现异步工作(含线程池的创建)
silence__is_gold的博客
05-11 3072
使用CompleteableFuture实现异步工作（含线程池的创建）
CompletableFuture开启异步线程
04-17
要使用CompletableFuture开启异步线程，可以按照以下步骤进行操作： 1. 创建一个CompletableFuture对象：可以使用CompletableFuture的静态方法`supplyAsync()`或`runAsync()`来创建一个CompletableFuture对象。`...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值