CompletableFuture使用

已于 2023-12-21 11:16:33 修改
阅读量173 收藏
点赞数
分类专栏： JAVA并发 文章标签： java junit 开发语言
于 2022-06-29 14:13:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tanhongwei1994/article/details/125521029
版权

CompletableFuture使用

package com.xiaobu.juc.CompeletableFuture;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.util.StopWatch;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Random;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.stream.Collectors;

/**
 * The type Completable future test.
 *
 * @author xiaobu
 * @className CompletableFutureTest.java
 * @createTime 2022年05月06日 10:07:00 get() 方法会抛出经检查的异常，可被捕获，自定义处理或者直接抛出。 <p> 而 join() 会抛出未经检查的异常。
 */
@Slf4j
public class CompletableFutureTest {
    /**
     * The constant fixedExecutorService.
     */
    public static ExecutorService fixedExecutorService = Executors.newFixedThreadPool(5);
    /**
     * junit测试多线程会有问题因为JUnit在主线程完成之后就会关闭JVM
     *
     * @see <a href="https://blog.csdn.net/fly910905/article/details/79210087">Junit单元测试不支持多线程测试--原因分析和问题解决</a>
     */
    StopWatch stopWatch = new StopWatch();

    /**
     * Gets user info.
     *
     * @return the user info
     */
    public static String getUserInfo() {
        try {
            TimeUnit.SECONDS.sleep(1L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "userInfo";
    }

    /**
     * Gets skill info.
     *
     * @return the skill info
     */
    public static String getSkillInfo() {
        try {
            TimeUnit.SECONDS.sleep(3L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "skillInfo";
    }

    /**
     * Before.
     */
    @Before
    public void before() {
        log.info("start");
        stopWatch.start();
    }

    /**
     * After.
     */
    @After
    public void after() {
        stopWatch.stop();
        log.info("end");
        // System.out.println("耗时= " + stopWatch.getTotalTimeSeconds());
        System.out.printf("耗时= %sS", stopWatch.getTotalTimeSeconds());
    }

    /**
     * 创建两个CompletableFuture执行异步任务
     */
    @SneakyThrows
    @Test
    public void testSupplyAsync() {
        //调用用户服务获取用户基本信息
        CompletableFuture<String> completableUserInfoFuture = CompletableFuture.supplyAsync(CompletableFutureTest::getUserInfo, fixedExecutorService);
        //模拟主线程其它操作耗时
        TimeUnit.SECONDS.sleep(2L);
        CompletableFuture<String> completableSkillInfoFuture = CompletableFuture.supplyAsync(CompletableFutureTest::getSkillInfo);
        String userInfo = completableUserInfoFuture.get();
        log.info("userInfo ==> 【{}】", userInfo);
        String skillInfo = completableSkillInfoFuture.get();
        log.info("skillInfo ==> 【{}】", skillInfo);
        // CompletableFuture<Void> voidCompletableFuture = CompletableFuture.allOf(completableUserInfoFuture, completableSkillInfoFuture);

    }

    /**
     * allOf 等待所有的 CompletableFuture 结束。并且没有返回值
     */
    @SneakyThrows
    @Test
    public void testSupplyAsyncAndAllOf() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start("testSupplyAsyncAndAllOf");
        //调用用户服务获取用户基本信息 1S
        CompletableFuture<String> completableUserInfoFuture = CompletableFuture.supplyAsync(CompletableFutureTest::getUserInfo, fixedExecutorService);
        //模拟主线程其它操作耗时
        TimeUnit.SECONDS.sleep(2L);
        //这个3S
        CompletableFuture<String> completableSkillInfoFuture = CompletableFuture.supplyAsync(CompletableFutureTest::getSkillInfo);
        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.allOf(completableUserInfoFuture, completableSkillInfoFuture);
        List<CompletableFuture<String>> completableFutureList = new ArrayList<>();
        completableFutureList.add(completableUserInfoFuture);
        completableFutureList.add(completableSkillInfoFuture);
        CompletableFuture<List<String>> completableFuture = voidCompletableFuture.thenApply(v -> {
            log.info("allOf ==> 【{}】", v);
            return completableFutureList.stream().map(CompletableFuture::join).collect(Collectors.toList());
        });
        stopWatch.stop();
        stopWatch.start("get");
        // 这里阻塞
        List<String> strings = completableFuture.get();
        System.out.println("strings = " + strings);
        stopWatch.stop();
        log.info("【testSupplyAsyncAndAllOf】::stopWatch.prettyPrint ==> 【{}】", stopWatch.prettyPrint());

    }

    /**
     * ThenRun方法
     * 做完第一个任务后，再做第二个任务。某个任务执行完成后，执行回调方法；但是前后两个任务没有参数传递，第二个任务也没有返回值
     */
    @SneakyThrows
    @Test
    public void testThenRun() {
        CompletableFuture<String> firstFuture = CompletableFuture.supplyAsync(() -> "first");
        //模拟主线程其它操作耗时
        TimeUnit.SECONDS.sleep(2L);
        CompletableFuture<Void> thenRun = firstFuture.thenRun(() -> log.info("firstFuture thenRun"));
        log.info("firstFuture.get() ==> 【{}】", firstFuture.get());
        log.info("thenRun.get() ==> 【{}】", thenRun.get());
    }

    /**
     * thenAccept方法
     * 第一个任务执行完成后，执行第二个回调方法任务，会将该任务的执行结果，作为入参，传递到回调方法中，但是回调方法是没有返回值的。
     */
    @SneakyThrows
    @Test
    public void testThenAccept() {
        CompletableFuture<String> firstFuture = CompletableFuture.supplyAsync(() -> "first");
        //模拟主线程其它操作耗时
        TimeUnit.SECONDS.sleep(2L);
        CompletableFuture<Void> thenAccept = firstFuture.thenAccept((s) -> {
            if (Objects.equals(s, "first")) {
                log.info("firstFuture thenAccept");
            } else {
                log.error("firstFuture thenAccept else");
            }
        });
        log.info("firstFuture.get() ==> 【{}】", firstFuture.get());
        log.info("thenAccept.get() ==> 【{}】", thenAccept.get());
    }

    /**
     * thenApply方法
     * 第一个任务执行完成后，执行第二个回调方法任务，会将该任务的执行结果，作为入参，传递到回调方法中，并且回调方法是有返回值的。
     */
    @SneakyThrows
    @Test
    public void testThenApply() {
        CompletableFuture<String> firstFuture = CompletableFuture.supplyAsync(() -> "first");
        //模拟主线程其它操作耗时
        TimeUnit.SECONDS.sleep(2L);
        CompletableFuture<String> thenApply = firstFuture.thenApply((s) -> {
            if (Objects.equals(s, "first")) {
                return "thenApply success";
            } else {
                return "thenApply error";
            }
        });
        log.info("firstFuture.get() ==> 【{}】", firstFuture.get());
        log.info("thenApply.get() ==> 【{}】", thenApply.get());
    }

    // ###########################################################异常处理exceptionally和handle########################################

    /**
     * exceptionally方法
     * 某个任务执行异常时，执行的回调方法;并且有抛出异常作为参数，传递到回调方法。
     */
    @SneakyThrows
    @Test
    public void testExceptionally() {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
                    throw new RuntimeException();
                })
                .exceptionally(ex -> "errorResultA")
                .thenApply(resultA -> resultA + " resultB")
                .thenApply(resultB -> resultB + " resultC")
                .thenApply(resultC -> resultC + " resultD");

        System.out.println(future.join());
    }

    /**
     * handle方法
     * handle 是执行任务完成时对结果的处理。
     * handle 方法和 thenApply 方法处理方式基本一样。不同的是 handle 是在任务完成后再执行，还可以处理异常的任务。thenApply 只可以执行正常的任务，任务出现异常则不执行 thenApply 方法。
     *
     * @throws Exception the exception
     */
    @Test
    public void handle() throws Exception {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                // int i = 10 / 0;
                return new Random().nextInt(10);
            }
        }).handle(new BiFunction<Integer, Throwable, Integer>() {
            @Override
            public Integer apply(Integer param, Throwable throwable) {
                int result = -1;
                if (throwable == null) {
                    result = param * 2;
                } else {
                    System.out.println(throwable.getMessage());
                }
                return result;
            }
        });
        System.out.println(future.get());
    }

    /**
     * whenComplete方法
     * whenComplete 方法是在任务完成后执行的回调方法。
     */
    @SneakyThrows
    @Test
    public void testWhenComplete() {
        CompletableFuture<String> firstFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("Thread.currentThread().getName() = " + Thread.currentThread().getName());
            return "firstFuture";
        });
        //模拟主线程其它操作耗时
        TimeUnit.SECONDS.sleep(2L);
        CompletableFuture<String> resFuture = firstFuture.whenComplete((a, throwable) -> {
            System.out.println("Thread.currentThread().getName() = " + Thread.currentThread().getName());
            System.out.println("上个任务执行完啦，还把" + a + "传过来");
        });
        // log.info("firstFuture.get() ==> 【{}】", firstFuture.get());
        log.info("resFuture.get() ==> 【{}】", resFuture.get());
    }

    /**
     * anyOf方法
     * runAfterEither
     */
    @SneakyThrows
    @Test
    public void testAnyOf() {
        // 两个CompletableFuture执行异步查询:
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "future1";
        });
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "future2";
        });
        // 用anyOf合并为一个新的CompletableFuture:
        CompletableFuture<Object> cfQuery = CompletableFuture.anyOf(future1, future2);
        // 两个CompletableFuture执行异步查询:
        CompletableFuture<Double> resFuture = cfQuery.thenApplyAsync((s) -> {
            return "future1".equals(s) ? 1.0 : 2.0;
        });
        log.info("future1.get() ==> 【{}】", future1.get());
        log.info("future2.get() ==> 【{}】", future2.get());
        log.info("resFuture.get() ==> 【{}】", resFuture.get());
    }

    /**
     * Run after either.
     */
    @Test
    public void runAfterEither() {
        // 两个CompletableFuture执行异步查询:
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "future1";
        });
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "future2";
        });
        CompletableFuture<Void> voidCompletableFuture = future1.runAfterEither(future2, () -> {
            log.info("有一个已经完成了。。。。。");
        });
        voidCompletableFuture.join();
    }


    /**
     * thenCombine 会把 两个 CompletionStage 的任务都执行完成后，把两个任务的结果一块交给 thenCombine 来处理
     *
     * @throws Exception the exception
     */
    @Test
    public void thenCombine() throws Exception {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "hello future1";
            }
        });
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(new Supplier<String>() {
            @Override
            public String get() {
                return "hello future2";
            }
        });
        CompletableFuture<String> result = future1.thenCombine(future2, new BiFunction<String, String, String>() {
            @Override
            public String apply(String t, String u) {
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return t + " " + u;
            }
        });
        System.out.println(result.get());
    }

    /**
     * 当两个CompletionStage都执行完成后，把结果一块交给thenAcceptBoth来进行消耗
     */
    @Test
    public void thenAcceptBoth() {
        CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                int t = 1;
                try {
                    TimeUnit.SECONDS.sleep(t);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("f1=" + t);
                return t;
            }
        });

        CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                int t = 2;
                try {
                    TimeUnit.SECONDS.sleep(t);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("f2=" + t);
                return t;
            }
        });
        CompletableFuture<Void> voidCompletableFuture = f1.thenAcceptBoth(f2, new BiConsumer<Integer, Integer>() {
            @Override
            public void accept(Integer t, Integer u) {
                System.out.println("f1=" + t + ";f2=" + u + ";");
            }
        });
        try {
            voidCompletableFuture.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }


    /**
     * Apply to either.
     *
     * @throws Exception the exception
     */
    @Test
    public void applyToEither() throws Exception {
        CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                int t = 2;
                try {
                    TimeUnit.SECONDS.sleep(t);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("f1=" + t);
                return t;
            }
        });
        CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                int t = 3;
                try {
                    TimeUnit.SECONDS.sleep(t);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("f2=" + t);
                return t;
            }
        });

        CompletableFuture<Integer> result = f1.applyToEither(f2, new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer t) {
                System.out.println(t);
                return t * 2;
            }
        });

        System.out.println(result.get());
    }

    /**
     * Accept either. 两个CompletionStage，谁执行返回的结果快，
     *
     * @throws Exception the exception
     */
    @Test
    public void acceptEither() throws Exception {
        CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                int t = 2;
                try {
                    TimeUnit.SECONDS.sleep(t);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("f1=" + t);
                return t;
            }
        });
        CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                int t = 3;
                try {
                    TimeUnit.SECONDS.sleep(t);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("f2=" + t);
                return t;
            }
        });

        CompletableFuture<Void> result = f1.acceptEither(f2, new Consumer<Integer>() {
            @Override
            public void accept(Integer t) {
                System.out.println(t);
            }
        });
        log.info("【acceptEither】::result.get() ==> 【{}】", result.get());
    }
}



package com.xiaobu.juc.CompletableFuture;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;

/**
 * @author xiaobu
 * @className CompletableFutureTest.java
 * @createTime 2022年05月06日 10:07:00
 * whenComplete回调不会阻塞主线程
 * Future 会阻塞主线程
 */
@Slf4j
public class CompletableFutureDemo3 {
    public static ExecutorService fixedExecutorService = Executors.newFixedThreadPool(5);

    public static void main(String[] args) throws Exception {
        try {
            futureTest();
            completableFutureTest();
            log.info("【main】::主线程 ");
            TimeUnit.SECONDS.sleep(5);
        } finally {
            fixedExecutorService.shutdown();
        }

    }

    private static void completableFutureTest() {
        log.info("【main】:: CompletableFuture start!");
        CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "CompletableFuture finished";
        }).whenComplete((r, t) -> {
            log.info("【main】::r ==> [{}],t ==> [{}]", r, t);
        });
    }

    private static void futureTest() throws InterruptedException, ExecutionException {
        log.info("【main】::Future start!");
        Future<?> future = fixedExecutorService.submit(() -> {
            TimeUnit.SECONDS.sleep(1);
            return "Future finished";
        });
        log.info("【main】::future.get() ==> [{}]", future.get());
    }


}

参考：
CompletableFuture 使用详解

小布2025
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在Spring Boot2中使用CompletableFuture的方法教程
08-26
本文将深入探讨如何在Spring Boot 2中有效地使用`CompletableFuture`。 首先，`@Async`注解允许我们标记一个方法为异步执行，这意味着该方法将在单独的线程中运行，而非阻塞当前的执行流程。为了启用这个特性，我们...
CompletableFuture模拟复杂场景使用测试。。。
大诚子的博客
01-11 934
CompletableFuture模拟复杂场景使用测试。。。
Java8 CompletableFuture使用
xktxoo的博客
07-08 1044
一、Future接口 1.1 Runnable与Callable Runnable接口源自JDK1.1，它只有一个run()方法，该方法没有返回结果： public interface Runnable { public abstract void run(); } Callable接口是JDK1.5中添加，只有一个call()方法，该方法支持结果返回且可以抛出异常： public ...
CompletableFuture的使用（详细）
最新发布
m0_72410274的博客
05-27 1146
completablefuture
CompletableFuture使用详解
热门推荐
sermonlizhi的博客
03-08 11万+
一、简介 1.1 概述 在上一篇文章《CompletionService使用与源码分析》中，已经介绍过了Future的局限性，它没法直接对多个任务进行链式、组合等处理，需要借助并发工具类才能完成，实现逻辑比较复杂。 而CompletableFuture是对Future的扩展和增强。CompletableFuture实现了Future接口，并在此基础上进行了丰富的扩展，完美弥补了Future的局限性，同时CompletableFuture实现了对任务编排的能力。借助这项能力，可以轻松地组织不同任务的运行顺序、
CompletableFuture
01-22
异步：使用 CompletableFuture 线程池其他线程运行任务，异步方法的名字中带有 Async。 1.runAsync（不接收参数、不返回参数） runAsync() 是 CompletableFuture 最常用的方法之一，它可以接收一个待运行的任务并...
CompletableFuture 异步处理
07-16
以下是一个简单的CompletableFuture使用示例，展示如何异步执行任务并处理结果： ```java Supplier<String> task = () -> { Thread.sleep(2000); // 模拟耗时操作 return "Task Result"; }; CompletableFuture...
Java8 CompletableFuture详解
09-04
Java 8 的 `CompletableFuture` 是对传统 `Future` 接口的重要扩展，它引入了丰富的功能，使得异步编程和事件驱动...通过使用 `CompletableFuture`，开发者能够更好地利用多核处理器的能力，提升程序的性能和响应速度。
CompletableFuture.zip
09-09
此外，`CompletableFuture`还支持链式调用，可以方便地与`CompletableFuture.allOf()`或`CompletableFuture.anyOf()`一起使用，以实现对多个异步任务的聚合或竞争。 总之，`CompletableFuture`是Java并发编程中的一...
一文搞懂CompletableFuture的使用
weixin_45987961的博客
01-24 4271
前言 创建线程的方式只有两种：继承Thread或者实现Runnable接口。 但是这两种方法都存在一个缺陷，没有返回值 Java 1.5 以后，可以通过向线程池提交一个Callable来获取一个包含返回值的Future对象 Future接口的局限性 当Future的线程进行了一个非常耗时的操作，那我们的主线程也就阻塞了。 当我们在简单业务上，可以使用Future的另一个重载方法get(long,TimeUnit)来设置超时时间，避免我们的主线程被无穷尽地阻塞。 单纯使用Future接口或者Fut
CompletableFuture使用详解（超详细）
javaeEEse的博客
02-20 7209
CompletableFuture就是帮你处理这些任务之间的逻辑关系，编排好任务的执行方式后，任务会按照规划好的方式一步一步执行，不需要让业务线程去频繁的等待。 比如说任务A，任务B，还有任务C。其中任务B还有任务C执行的前提是任务A先完成，再执行任务B和任务C。
CompletableFuture的使用
Evan's Blog ٩(๑❛ᴗ❛๑)۶
03-20 8721
现在大部分的CPU都是多核，我们都知道想要提升我们应用程序的运行效率，就必须得充分利用多核CPU的计算能力；Java为我们提供了大量多线程API，使用它们可以让我们的代码避免同步阻塞，从而达到提升运行效率的目的，CompletableFuture就是其中一个非常强大且重要API，下面我们就来介绍一下CompletableFuture的概念和使用。
异步编排CompletableFuture
cybxh的博客
09-10 302
CompletableFuture异步调用 问题：查询商品详情页的逻辑非常复杂，数据的获取都需要远程调用，必然需要花费更多的时间。 假如商品详情页的每个查询，需要如下标注的时间才能完成 // 1. 获取sku的基本信息 0.5s // 2. 获取sku的图片信息 0.5s // 3. 获取sku的促销信息 TODO 1s // 4. 获取spu的所有销售属性 1s // 5. 获取规格参数组及组下的规格参数 TODO 1.5s // 6. spu详情 TODO 1s ......... 那么，
多线程基础（八）CompletableFuture使用详解
m0_47743175的博客
06-18 5331
CompletableFuture使用详解
CompletableFuture使用详解（全网看这一篇就行）
星哲最开心
07-31 4519
CompletableFuture使用详解（全网看这一篇就行）
Java8特性 - CompletableFuture的基础使用
Zong_0915的博客
10-19 1217
Java8特性 - CompletableFuture的基础使用
completablefuture使用
07-28
这个例子中，使用 thenCombine 方法将两个 CompletableFuture 对象组合起来，并返回一个新的 CompletableFuture 对象。 还有其他的方法可以实现类似的操作,如: thenAccept,thenRun,exceptionally等等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值