CompletableFuture 常用方法介绍

最新推荐文章于 2025-03-23 12:10:39 发布
最新推荐文章于 2025-03-23 12:10:39 发布
阅读量839 收藏 7
点赞数 11
文章标签： java 分布式 spring cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wang20010104/article/details/145469930
版权

CompletableFuture 是 Java 8 引入的一个强大的异步编程工具类，它实现了 Future 和 CompletionStage 接口，提供了丰富的方法来处理异步任务的创建、组合、结果获取等操作。以下是对 CompletableFuture 基本异步方法的详细介绍：

1. 创建异步任务

runAsync(Runnable runnable)

  • 功能：以异步方式执行一个 Runnable 任务，不返回结果。默认使用 ForkJoinPool.commonPool() 线程池。
  • 示例代码：

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Running task asynchronously...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Task completed.");
        });

        // 等待任务完成
        future.join();
    }
}
runAsync(Runnable runnable, Executor executor)

  • 功能：以异步方式执行一个 Runnable 任务，不返回结果，使用指定的线程池 executor。
  • 示例代码：

java

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Running task asynchronously with custom executor...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Task completed.");
        }, executor);

        // 等待任务完成
        future.join();
        executor.shutdown();
    }
}
supplyAsync(Supplier<U> supplier)

  • 功能：以异步方式执行一个 Supplier 任务，返回一个 CompletableFuture 对象，该对象最终会包含 Supplier 的返回值。默认使用 ForkJoinPool.commonPool() 线程池。
  • 示例代码：

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("Running task asynchronously...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Task result";
        });

        // 获取任务结果
        String result = future.join();
        System.out.println("Result: " + result);
    }
}
supplyAsync(Supplier<U> supplier, Executor executor)

  • 功能：以异步方式执行一个 Supplier 任务，返回一个 CompletableFuture 对象，该对象最终会包含 Supplier 的返回值，使用指定的线程池 executor。
  • 示例代码：

java

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("Running task asynchronously with custom executor...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Task result";
        }, executor);

        // 获取任务结果
        String result = future.join();
        System.out.println("Result: " + result);
        executor.shutdown();
    }
}

2. 处理任务结果

thenApply(Function<? super T,? extends U> fn)

  • 功能：当 CompletableFuture 完成时，对其结果应用一个函数，并返回一个新的 CompletableFuture，该新 CompletableFuture 的结果是函数的返回值。
  • 示例代码：

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
               .thenApply(s -> s + " World");

        String result = future.join();
        System.out.println(result); // 输出: Hello World
    }
}
thenAccept(Consumer<? super T> action)

  • 功能：当 CompletableFuture 完成时，对其结果执行一个消费操作，不返回结果，返回的 CompletableFuture 类型为 CompletableFuture<Void>。
  • 示例代码：

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> "Hello")
               .thenAccept(s -> System.out.println(s));

        future.join(); // 输出: Hello
    }
}
thenRun(Runnable action)

  • 功能：当 CompletableFuture 完成时，执行一个 Runnable 任务，不关心原任务的结果，返回的 CompletableFuture 类型为 CompletableFuture<Void>。
  • 示例代码：

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> "Hello")
               .thenRun(() -> System.out.println("Task completed"));

        future.join(); // 输出: Task completed
    }
}

3. 组合多个 CompletableFuture

thenCompose(Function<? super T, ? extends CompletionStage<U>> fn)

  • 功能：当 CompletableFuture 完成时，将其结果传递给一个函数，该函数返回另一个 CompletionStage，最终返回一个新的 CompletableFuture，该新 CompletableFuture 的结果是嵌套 CompletionStage 的结果。
  • 示例代码：

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
               .thenCompose(s -> CompletableFuture.supplyAsync(() -> s + " World"));

        String result = future.join();
        System.out.println(result); // 输出: Hello World
    }
}
thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)

  • 功能：当当前 CompletableFuture 和另一个 CompletionStage 都完成时，将它们的结果传递给一个二元函数，并返回一个新的 CompletableFuture，该新 CompletableFuture 的结果是二元函数的返回值。
  • 示例代码：

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> " World");

        CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (s1, s2) -> s1 + s2);

        String result = combinedFuture.join();
        System.out.println(result); // 输出: Hello World
    }
}
allOf(CompletableFuture<?>... cfs)

  • 功能：返回一个新的 CompletableFuture，当所有给定的 CompletableFuture 都完成时，该新 CompletableFuture 完成。它不返回任何结果，类型为 CompletableFuture<Void>。
  • 示例代码：

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Result 1");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Result 2");

        CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2);

        allFutures.join();
        System.out.println("All tasks completed");
    }
}
anyOf(CompletableFuture<?>... cfs)

  • 功能：返回一个新的 CompletableFuture，当任何一个给定的 CompletableFuture 完成时，该新 CompletableFuture 完成，其结果是第一个完成的 CompletableFuture 的结果。
  • 示例代码：

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result 1";
        });
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Result 2";
        });

        CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(future1, future2);

        Object result = anyFuture.join();
        System.out.println("First completed result: " + result); // 输出: Result 2
    }
}

4. 异常处理

exceptionally(Function<Throwable, ? extends T> fn)

  • 功能：当 CompletableFuture 出现异常时，将异常传递给一个函数，该函数返回一个默认值，最终返回一个新的 CompletableFuture，其结果是函数的返回值。
  • 示例代码：

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Something went wrong");
        }).exceptionally(ex -> {
            System.out.println("Exception caught: " + ex.getMessage());
            return "Default result";
        });

        String result = future.join();
        System.out.println(result); // 输出: Default result
    }
}
handle(BiFunction<? super T, Throwable, ? extends U> fn)

  • 功能：无论 CompletableFuture 是否完成或出现异常，都将结果（或 null，如果出现异常）和异常（或 null，如果没有异常）传递给一个二元函数，并返回一个新的 CompletableFuture，其结果是二元函数的返回值。
  • 示例代码：

java

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Something went wrong");
        }).handle((result, ex) -> {
            if (ex != null) {
                System.out.println("Exception caught: " + ex.getMessage());
                return "Default result";
            }
            return result;
        });

        String result = future.join();
        System.out.println(result); // 输出: Default result
    }
}

以上就是 CompletableFuture 的一些基本异步方法的介绍，通过这些方法可以方便地进行异步编程和任务组合。

java 8 新特性功能和用法介绍03---CompletableFuture基本用法介绍
weixin_43946605的博客
11-27 519
Java8 CompletableFuture java 8 新增CompletableFuture类简化异步编程的复杂性，提供函数式编程的能力，并且可以通过回调的方式处理计算结果。同时解决了 传统异步编程Future模式的缺点，对于异步执行结果，只能通过等待get操作以及轮询isDone去判断Future是否完成，是非常耗费CPU资源。而CompletableFuture 弥补了Future模式的缺点，在异步的任务完成后，需要用其结果继续操作时，无需等待。可以直接通过thenAccept、thenAppl
CompletableFuture用法详解
qq_36042938的博客
08-09 3120
小笔记
CompletableFuture中join与get的区别
tszc95的博客
09-24 1606
使用 get() 时需要注意处理 InterruptedException 和 ExecutionException。如果需要对异常进行更细粒度的控制，比如区分执行异常和取消异常，或者需要设置超时，那么应该使用 get()。如果希望代码更简洁，并且不介意直接处理原始异常，那么 join() 是一个更好的选择。在实际开发中，根据需求选择合适的方法。如果想简单地获取结果而不关心具体的异常类型，join() 通常更为方便。
并发编程之发现CompletableFuture的runAsync方法中的线程池辛秘
小宝潜行的博客
03-23 904
并发编程之发现CompletableFuture的runAsync方法中的线程池辛秘，避免ForkJoinPool线程池失效，而引发CPU飙升问题
Java并发魔法：CompletableFuture 全解析 CompletableFuture类提供了join()和get() 看这一篇就够了
赵KK的博客
05-29 5196
在Java的世界里，是异步编程的利器，它为开发者提供了强大的异步处理能力。今天，就让我们一起揭开的神秘面纱，深入了解它的使用方法、运行原理、应用场景以及源码分析。
Java并发编程—CompletableFuture的常用方法（建议收藏）
小魏快起床的博客
12-07 2490
2、T get(long timeout, TimeUnit unit){}方法： 功能：get()方法需要等待线程执行完后才能获取到，这个是设置了一个等待时间，如果在设定的等待时间没获取到，就报错； 3、T join(){}方法: 功能：和get()的功能一样，只是这个方法不需要抛异常 4、T getNow(T valueIfAbsent){}方法
CompletableFuture 常见方法总结
张紫娃的博客
04-19 594
【代码】CompletableFuture。
CompletableFuture常用方法
weixin_45486746的博客
05-25 8890
1.创建异步任务 CompletableFuture.runAsync():创建一个没有返回值的异步任务。 CompletableFuture<Void> runComplete = CompletableFuture.runAsync(()-> System.out.println("没有返回值的异步任务")); CompletableFuture.supplyAsync():常见一个有返回值的异步任务。 CompletableFuture<String> support
CompletableFuture常用方法详解
你就像甜甜的益达
04-27 5121
文章目录初始化CompletableFuture常用方法获取返回结果:异步执行结果(相当于设置处理器,执行完成,自动执行处理器,异步): 初始化CompletableFuture CompletableFuture有五个静态方法, 这个返回已经计算好结果的,封装为CompletableFuture返回(我在想,既然已经计算好了,那我还要使用CompletableFuture干啥?我使用Compl...
CompletableFuture常用方法介绍
最新发布
04-16
</think>### CompletableFuture常用方法及使用示例 #### 一、创建异步任务 1. **supplyAsync** 用于创建带返回值的异步任务，默认使用`ForkJoinPool`执行。 ```java CompletableFuture<String> future = ...
CompletableFuture功能介绍与原理分析
尘间絮的专栏
08-10 3932
CompletableFuture功能介绍与原理简析前言CompletableFuture功能介绍1.创建CompletableFuture2.CompletableFuture结果的获取3.CompletableFuture的执行状态控制4.CompletionStage接口方法的实现1）是否异步执行2）输入参数与输出结果3）依赖的CompletionStage个数4）是否可接收异常结果并处理CompletableFuture实现原理分析概念介绍1.UnSafe的应用2.Treiber stack3.Fo
[AIGC] CompletableFuture的重要方法有哪些？
程序员三木的博客
06-09 517
当CompletableFuture的计算结果完成后，该方法返回一个新的CompletableFuture，这个新的CompletableFuture会对结果进行函数的处理。: 当CompletableFuture的计算结果完成后异步进行如下操作，通过ForkJoinPool.commonPool()作为它的线程池执行后续的Runnable参数。: 当原有的CompletableFuture产出异常时，调用function，输入异常，返回新的值。
CompletableFuture 方法总结
weixin_40980639的博客
07-05 768
纯消费类型的方法，指依赖上一个异步任务的结果作为当前函数的参数进行下一步计算，它的特点是不返回新的计算值，这类的方法都包含 Accept 这个关键字。在CompletionStage中包含9个Accept关键字的方法，这9个方法又可以分为三类：依赖单个CompletionStage任务完成，依赖两个CompletionStage任务都完成，依赖两个CompletionStage中的任何一个完成。 例子 thenAcceptBothAsync 拿到supplyAsync方法和completableFuture
CompletableFuture在日常开发中常用方法示例
weixin_43529116的博客
04-23 292
本文记录CompletableFuture在日常开发中我常用方法的示例,记录于此,便于加深自己的理解 thenApplyAsync:表示某个任务执行完成后执行的动作，即回调方法，会将该任务的执行结果即方法返回值作为入参传递到回调方法中 在CompletableFuture中也可以自定义线程池,如果不自定义,默认使用ForkJoinPool @Test public void test1() throws Exception { CompletableFuture<
CompletableFuture 基本用法
qq_44286009的博客
06-22 2625
是 Java 8 引入的一个功能强大的类，用于异步编程和并发处理。它提供了丰富的 API 来处理异步任务的结果，支持函数式编程风格，并允许通过链式调用组合多个异步操作。
CompletableFuture使用方法详细说明
weixin_37799575的博客
08-27 5104
CompletableFuture的get()方法是阻塞的，我们一般建议使用future.get(3, TimeUnit.SECONDS)。并且一般建议使用自定义线程池。但是如果线程池拒绝策略是DiscardPolicy或者DiscardOldestPolicy，当线程池饱和时，会直接丢弃任务，不会抛弃异常。因此建议，CompletableFuture线程池策略最好使用AbortPolicy，然后耗时的异步线程，做好线程池隔离。...
CompletableFuture使用（全网最详细！！！）
热门推荐
国家专精特新小巨人、资深消防行业企业、国家高新技术企业、智慧消防技术实验室、准独角兽企业、浙江省电流AI技术研发中心
06-26 1万+
前言普通情况下，我们的接口逻辑都是串行化的，有时候在我们方法中可能存在着非常耗时的操作这样就会造成代码阻塞，但是呢，为了用户的体验，我们可能需要将一些复杂的数据开启线程进行异步处理。所谓异步，其实就是实现一个可无需等待被调用函数的返回值而让操作继续运行的方法，简单的讲就是另启一个线程来完成调用中的部分计算，使调用继续运行或返回，而不需要等待计算结果。Java8 提供的可以自定义线程池或使用默认线程池对数据进行异步处理，且可以根据需求选择是否返回异步结果！灵活的使用。
CompletableFuture常用方法（基于Java8）
liwenyang1992的专栏
04-21 866
CompletableFuture
CompletableFuture常见使用方法
weixin_42682398的博客
12-30 299
FutureTask在获取结果的时候会阻塞 ，而CompletableFuture异步回调你的方法，不进行阻塞的获得结果，完成你获得结果后想做的事情。CompletableFuture既可以通过future等待执行结果，又可以使用completionStage去增强异步回调的功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雨会停rain

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值