一篇文章学会使用 CompletableFuture（JDK9）

最新推荐文章于 2024-04-30 10:29:27 发布
最新推荐文章于 2024-04-30 10:29:27 发布
阅读量6.7k 收藏 13
点赞数 11
分类专栏： Java并发 文章标签： java 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shockang/article/details/121323936
版权

前言

本文隶属于专栏《100个问题搞定Java并发》，该专栏为笔者原创，引用请注明来源，不足和错误之处请在评论区帮忙指出，谢谢！

本专栏目录结构和参考文献请见100个问题搞定Java并发

正文

CompletableFuture 是 Java8 新增的一个超大型工具类。

为什么说它大呢?

因为它实现了 Future 接口，而更重要的是，它也实现了 CompletionStage 接口。

CompletionStage 接口也是 Java8 中新增的，它拥有多达约 40 种方法!

是的，你没有看错，这看起来完全不符合设计中所谓的“单方法接口”原则，但是在这里，它就这么存在了。

这个接口拥有如此众多的方法，是为函数式编程中的流式调用准备的。

通过 Completionstage 接口，我们可以在个执行结果上进行多次流式调用，以此可以得到最终结果。

比如，你可以在一个 CompletionStage 接口上进行如下调用:

stage.thenApply(x -> square(x)).thenAccept(x -> System.out.print(x)).thenRun (()-> System.out.println());

这一连串的调用就会依次执行。

1、完成了就通知我

CompletableFuture 和 Future 一样，可以作为函数调用的契约。

向 CompletableFuture 请求一个数据，如果数据还没有准备好，请求线程就会等待。

而让人惊喜的是，我们可以手动设置 CompletableFuture 的完成状态。

package com.shockang.study.java.concurrent.completable;

import java.util.concurrent.CompletableFuture;

/**
 * 脱离线程池的使用，仅作为一个契约
 *
 * @author Shockang
 */
public class CFutureMain1 {
	public static class AskThread implements Runnable {
		CompletableFuture<Integer> re = null;

		public AskThread(CompletableFuture<Integer> re) {
			this.re = re;
		}

		@Override
		public void run() {
			int myRe = 0;
			try {
				myRe = re.get() * re.get();
			} catch (Exception e) {
			}
			System.out.println(myRe);
		}
	}

	public static void main(String[] args) throws InterruptedException {
		final CompletableFuture<Integer> future = new CompletableFuture<>();
		new Thread(new AskThread(future)).start();
		// 模拟长时间其他调用
		Thread.sleep(1000);
		// 告知完成结果
		future.complete(60);
	}
}


3600

2、异步执行任务

通过 CompletableFuture 提供的进一步封装，我们很容易实现 Future 模式那样的异步调用。

package com.shockang.study.java.concurrent.completable;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * 完成普通future的工作
 * <p>
 * 以下几个函数可以执行（创建）一个CompletableFuture任务
 * static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier);
 * static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor);
 * static CompletableFuture<Void> runAsync(Runnable runnable);
 * static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor);
 *
 * @author Shockang
 */
public class CFutureMain2 {
	public static Integer calc(Integer para) {
		try {
			// 模拟一个长时间的执行
			Thread.sleep(1000);
		} catch (InterruptedException e) {
		}
		return para * para;
	}

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		final CompletableFuture<Integer> future =
				CompletableFuture.supplyAsync(() -> calc(50));
		System.out.println(future.get());
	}
}


2500

在 CompletableFuture 中，类似的工厂方法如下所示。

    /**
     * Returns a new CompletableFuture that is asynchronously completed
     * by a task running in the {@link ForkJoinPool#commonPool()} with
     * the value obtained by calling the given Supplier.
     *
     * @param supplier a function returning the value to be used
     * to complete the returned CompletableFuture
     * @param <U> the function's return type
     * @return the new CompletableFuture
     */
    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
        return asyncSupplyStage(asyncPool, supplier);
    }

    /**
     * Returns a new CompletableFuture that is asynchronously completed
     * by a task running in the given executor with the value obtained
     * by calling the given Supplier.
     *
     * @param supplier a function returning the value to be used
     * to complete the returned CompletableFuture
     * @param executor the executor to use for asynchronous execution
     * @param <U> the function's return type
     * @return the new CompletableFuture
     */
    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
                                                       Executor executor) {
        return asyncSupplyStage(screenExecutor(executor), supplier);
    }

    /**
     * Returns a new CompletableFuture that is asynchronously completed
     * by a task running in the {@link ForkJoinPool#commonPool()} after
     * it runs the given action.
     *
     * @param runnable the action to run before completing the
     * returned CompletableFuture
     * @return the new CompletableFuture
     */
    public static CompletableFuture<Void> runAsync(Runnable runnable) {
        return asyncRunStage(asyncPool, runnable);
    }

    /**
     * Returns a new CompletableFuture that is asynchronously completed
     * by a task running in the given executor after it runs the given
     * action.
     *
     * @param runnable the action to run before completing the
     * returned CompletableFuture
     * @param executor the executor to use for asynchronous execution
     * @return the new CompletableFuture
     */
    public static CompletableFuture<Void> runAsync(Runnable runnable,
                                                   Executor executor) {
        return asyncRunStage(screenExecutor(executor), runnable);
    }

其中 supplyAsync() 方法用于那些需要返回值的场景，比如计算某个数据等。

而 runAsync() 方法用于没有返回值的场景，比如，仅仅是简单地执行某一个异步动作。

在这两对方法中，都有一个方法可以接收一个 Executor 参数。

这就使我们可以让 Supplier< U > 或者 Runnable 在指定的线程池中工作。

如果不指定，则在默认的系统公共的 ForkJoinPool.common 线程池中执行。

注意:在 Java8 中，新増了 ForkJoinPool.commonPool() 方法。 它可以获得一个公共的 ForkJoin 线程池。 这个公共线程池中的所有线程都是 Daemon 线程。 这意味着如果主线程退出，这些线程无论是否执行完毕，都会退出系统。

3、流式调用

在前文中我已经提到， CompletionStage 的 40 个接口是为函数式编程做准备的。

在这里，就让我们看一下，如何使用这些接口进行函数式的流式 API 调用。

package com.shockang.study.java.concurrent.completable;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * 完成普通future的工作
 * <p>
 * 以下几个函数可以执行（创建）一个CompletableFuture任务
 * thenApply 转换
 * thenAccept 最后处理
 *
 * @author Shockang
 */
public class CFutureMain3 {
	public static Integer calc(Integer para) {
		try {
			// 模拟一个长时间的执行
			Thread.sleep(1000);
		} catch (InterruptedException e) {
		}
		return para * para;
	}

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		CompletableFuture<Void> fu = CompletableFuture.supplyAsync(() -> calc(50))
				.thenApply((i) -> Integer.toString(i))
				.thenApply((str) -> "\"" + str + "\"")
				.thenAccept(System.out::println);
		fu.get();
	}
}


"2500"

4、异常处理

如果 CompletableFuture 在执行过程中遇到异常，那么我们可以用函数式编程的风格来优雅地处理这些异常。

CompletableFuture 提供了一个异常处理方法 exceptionally() :

package com.shockang.study.java.concurrent.completable;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * 完成普通future的工作
 * <p>
 * exceptionally 异常处理 发生异常进行处理，如果没有异常，则它返回原有的结果
 *
 * @author Shockang
 */
public class CFutureMain4 {

	public static Integer calc(Integer para) {
		return para / 0;
	}

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		CompletableFuture<Void> fu = CompletableFuture
				.supplyAsync(() -> calc(50))
				.exceptionally(ex -> {
					System.out.println(ex.toString());
					return 0;
				})
				.thenApply((i) -> Integer.toString(i))
				.thenApply((str) -> "\"" + str + "\"")
				.thenAccept(System.out::println);
		fu.get();
	}

}

java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
"0"

5、组合多个 CompletableFuture

CompletableFuture 还允许你将多个 CompletableFuture 进行组合。

thenCompose()

一种方法是使用 thenCompose() 方法，它的签名如下:

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

一个 CompletableFuture 可以在执行完成后，将执行结果通过 Function 接口传递给下个 CompletionStage 实例进行处理。

Function 接口返回新的 CompletionStage 实例。

package com.shockang.study.java.concurrent.completable;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * 完成普通future的工作
 * <p>
 * thenCompose
 *
 * @author Shockang
 */
public class CFutureMain5 {

	public static Integer calc(Integer para) {
		return para / 2;
	}

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		CompletableFuture<Void> fu =
				CompletableFuture.supplyAsync(() -> calc(50))
						.thenCompose((i) -> CompletableFuture.supplyAsync(() -> calc(i)))
						.thenApply((str) -> "\"" + str + "\"").thenAccept(System.out::println);
		fu.get();
	}

}


"12"

thenCombine()

另外一种组合多个 CompletableFuture 的方法是 thenCombine() 方法，它的签名如下:

public <U,V> CompletableFuture<V> thenCombine(
        CompletionStage<? extends U> other,
        BiFunction<? super T,? super U,? extends V> fn)

方法 thenCombine() 首先完成当前 CompletableFuture 和 other 的执行。
接着，将这两者的执行结果传递给 BiFunction (该接口接收两个参数，并有一个返回值)，并返回代表 BiFunction 实例的 CompletableFuture 对象。

package com.shockang.study.java.concurrent.completable;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * 完成普通future的工作
 * <p>
 * thenCombine 合并结果
 *
 * @author Shockang
 */
public class CFutureMain6 {

	public static Integer calc(Integer para) {
		return para / 2;
	}

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		CompletableFuture<Integer> intFuture = CompletableFuture.supplyAsync(() -> calc(50));
		CompletableFuture<Integer> intFuture2 = CompletableFuture.supplyAsync(() -> calc(25));

		CompletableFuture<Void> fu = intFuture.thenCombine(intFuture2, (i, j) -> (i + j))
				.thenApply((str) -> "\"" + str + "\"")
				.thenAccept(System.out::println);
		fu.get();
	}

}

"37"

6、支持 timeout（JDK9）

在 JDK9 以后 CompletableFuture 增加了 timeout功能。

如果一个任务在给定时间内没有完成,则直接抛出异常。

package com.shockang.study.java.concurrent.completable;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class CFutureMain7 {

	public static Integer calc(Integer para) {
		return para / 2;
	}

	public static void main(String[] args) {
		CompletableFuture.supplyAsync(() -> {
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
			}
			return calc(50);

		}).orTimeout(1, TimeUnit.SECONDS).exceptionally(e -> {
			System.err.println(e);
			return 0;
		}).thenAccept(System.out::println);

		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
		}
	}
}


java.util.concurrent.TimeoutException
0
Shockang
关注
  • 11
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
JDK9 中文 chm
03-29
JDK9提供了一个新的内置HTTP客户端API（`java.net.http`包），取代了之前不推荐使用的`java.net.URL`和`java.net.HttpURLConnection`。新API支持HTTP/2和WebSocket协议，提供了异步和同步两种操作模式，以及更好的...
异步编程——CompletableFuture用法详解
kezhou的博客
02-19 1066
我们异步执行一个任务时，需要用线程池Executor如果不需要有返回值， 任务继承Thread类或实现Runnable接口；如果需要有返回值，任务实现Callable接口，调用Executor的submit方法执行任务，再使用获取任务结果。当我们得到包含结果的Future时，我们可以使用get方法等待线程完成并获取返回值，但问题是Future的get()方法会阻塞主线程。并且当多个线程存在依赖组合的时候，使用同步组件CountDownLatch是比较麻烦的。Java8新增的类提供了非常强大的。
JAVA中的异步CompletableFuture
kingtok的博客
04-11 2458
CompletableFuture 1.8新特性 异步任务
【java9】java9新特性之CompletableFuture的新API
最新发布
morris
04-30 9985
CompletableFuture是Java8引入的一个功能强大的类，用于处理异步编程和函数式编程。它提供了许多方法来组合多个异步操作，使得处理异步任务变得更加简单和直观。
二、一篇学会CompletableFuture
PingFanXianSheng的博客
07-27 1620
Future接口、FutureTask、CompletableFuture详细使用以及讲解
CompletableFuture
很多时候犯错都是在不知情的情况下发生的
09-25 716
使用Future获得异步执行结果时，要么调用阻塞方法get()，要么轮询看isDone()是否为true，这两种方法都不是很好，因为主线程也会被迫等待。 从Java 8开始引入了CompletableFuture，它针对Future做了改进，可以传入回调对象，当异步任务完成或者发生异常时，自动调用回调对象的回调方法。 我们以获取股票价格为例，看看如何使用CompletableFuture： // CompletableFuture import java.util.concurrent.Comple
java8新特性CompletableFuture
haoweng4800的博客
04-19 84
public class Main { public static void main(String[] args) throws Exception { // 两个CompletableFuture执行异步查询: CompletableFuture<String> cfQueryFromSina = CompletableFuture.su...
深入解析CompletableFuture的功能和用法
weixin_46993901的博客
07-14 600
是 Java 8 中引入的一个类，它实现了接口，提供了一组丰富的方法来处理异步操作和多个任务的结果。它支持链式操作，可以方便地处理任务的依赖关系和结果转换。相比于传统的Future接口，更加灵活和强大。掘金博客我们还可以通过指定自定义线程池来创建 CompletableFuture 对象，以满足特定的并发需求。// 执行任务的代码在上述示例中，我们通过创建了一个固定大小为 10 的自定义线程池，并将其传递给方法来执行异步任务。
linux系统的jdk9.rar
07-03
Linux系统中的JDK9安装与使用详解 在Linux环境下，Java Development Kit（JDK）是进行Java编程的基础，而JDK9是Oracle公司发布的一个重要版本，它包含了许多新特性和改进。本教程将详细介绍如何在Linux系统中安装并...
jdk9 api 中文版
09-17
在"jdk9 api 中文版"中，我们可以找到JDK 9的所有API的中文文档，这对于中文用户来说是一个极大的便利。文档通常分为多个部分，包括核心类库、JDBC、网络编程、多线程、I/O流、集合框架、国际化、安全管理等。以下是...
jdk9 windows版本64位系统
04-10
windows版本64位操作系统的jdk9，从java官网下载，具体版本号 jdk-9+181_windows-x64_ri.zip
JDK14性能管理工具之jstack使用介绍
10-15
jstack工具主要用来打印java堆栈信息，主要是java的class名字，方法名，字节码索引，行数等信息。这篇文章主要介绍了JDK14性能管理工具之jstack使用介绍,需要的朋友可以参考下
并发编程之CompletableFuture异步编排的详细介绍和基本使用（全网最细最全）
m0_56466015的博客
03-20 2986
CompletableFutyre异步编排最详细介绍和所有用法的举例说明（附源码），全网最全最细
JDK 9 future orTimeout及completeOnTimeout 记录
weixin_40455124的博客
02-22 904
future 在jdk 8 通常是通过get(long timeout, TimeUnit unit)或者使用applyToEither来控制超时。 在JDK 9以后可以使用 future.completeOnTimeout(status, 10 * 1000, TimeUnit.MILLISECONDS); 或者 future.orTimeout(5 * 1000, TimeUnit.MILLISECONDS); 使用get会阻塞主线程（发起future的线程），而其它都是要多启用一个线程，包括jdk9
线程状态-线程停止 stop
Tokisaki_Kurumi的博客
09-10 336
//测试stop //1.建议线程正常停止--->利用次数，不建议死循环 //2.建议使用标志位--->设置一个标志位 //3.不要使用stop或者destroy等过时或者JDK不建议使用的方法 public class TestStop implements Runnable{ //1.设置一个标志位 private boolean flag = true; @Override public void run() { int i = 0;
java如何正确关闭线程以及线程池（代码实践含源码分析）
码农研究僧的博客
04-17 9012
这个问题是一个高频的面试题 而且在印象中是由stop方法执行或者终端中的kill杀死 但是这些方法直接简单粗暴，很不安全，而且也不推广 不使用stop的方法 之所以不安全不推广是因为： stop方法不管线程逻辑是否完整，都会终止当前正在运行的线程 会破坏其原子逻辑（多线程加了锁之解决资源共享，但是stop会将其所有锁丢弃，造成混乱）
并发编程之 CompletableFuture
搬运Gong
06-19 1542
CompletableFuture 异步编程
CompletableFuture使用教学
Gufang617的博客
05-09 862
主要讲解CompletableFuture的使用
【异步编程学习笔记】JDK中的FutureTask和CompletableFuture详解（使用示例、源码）
qq_41358574的博客
09-28 1227
FutureTask概述 FutureTask代表了一个可被取消的异步计算任务，该类实现了Future接口，比如提供了启动和取消任务、查询任务是否完成、获取计算结果的接口。 FutureTask任务的结果只有当任务完成后才能获取，并且只能通过get系列方法获取，当结果还没出来时，线程调用get系列方法会被阻塞。另外，一旦任务被执行完成，任务将不能重启，除非运行时使用了runAndReset方法。FutureTask中的任务可以是Callable类型，也可以是Runnable类型（因为FutureTask实现
jdk8 completablefuture 示例代码
03-08
以下是 JDK8 CompletableFuture 的示例代码： CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> { try { Thread.sleep(100); } catch (InterruptedException e) { throw new IllegalStateException(e); } return "Hello"; }).thenApplyAsync(result -> result + " World"); String result = future.get(); System.out.println(result); 这段代码创建了一个 CompletableFuture 对象，使用 supplyAsync 方法异步执行一个任务，然后使用 thenApplyAsync 方法对任务的结果进行处理，最后通过 get 方法获取最终的结果并输出。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值