关于 CompletableFuture， 引用 baeldung 中的一句话：

The best part of the CompletableFuture API is the ability to combine CompletableFuture instances in a chain of computation steps.

本文整理了 CompletableFuture 一些常用的方法，方便日后需要的时候查看。

回调

/**
 * 总结：
 * run：没参数传递，没返回值
 * accept：有参数传递，没返回值
 * apply：有参数传递，有返回值
 *
 * @author LBG - 2022/12/3
 */
public class CompletableFutureDemo {

	public static void main(String[] args) throws Exception {
		//runAsync();
		//supplyAsync();

		//thenRun();

		//thenAccept();

		//thenApply();

		//exceptionally();

		//whenComplete();

		 handle();

		Thread.sleep(1000L);
	}

	/****************** 创建异步任务 ******************/

	/**
	 * 创建一个无返回值的异步任务
	 */
	private static void runAsync() {
		CompletableFuture<Void> future = CompletableFuture.runAsync(() -> System.out.println("runAsync demo"));
	}

	/**
	 * 创建一个有返回值的异步任务
	 */
	private static void supplyAsync() throws Exception {
		CompletableFuture<String> supplyAsync = CompletableFuture.supplyAsync(() -> "has return value");
		System.out.println(supplyAsync.get());
	}

	/****************** 异步任务完成后回调（没有参数传递，没有返回值） ******************/

	/**
	 * 两个任务之间没有参数传递，且没有返回值
	 */
	private static void thenRun() {
		CompletableFuture<Void> voidFuture =
				CompletableFuture.supplyAsync(() -> "return value is thenRun")
						.thenRun(() -> System.out.println("then run"));
	}

	/**
	 * 和 thenRun 的区别就是 thenRunAsync 可以传入自定义线程池
	 */
	private static void thenRunAsync() {
		CompletableFuture<Void> voidFuture =
				CompletableFuture.supplyAsync(() -> "return value is thenRunAsync")
						.thenRunAsync(() -> System.out.println("thenRunAsync"));
	}

	/****************** 异步任务完成后回调（有参数传递，没有返回值） ******************/

	/**
	 * 两个任务之间有参数传递，没有返回值
	 */
	private static void thenAccept() {
		// thenAccept thenAcceptAsync 区别：后者可以传入线程池
		CompletableFuture<Void> voidFuture =
				CompletableFuture.supplyAsync(() -> "thenAccept value")
						.thenAccept((value) -> System.out.println("previous value is " + value));

		//ExecutorService pool = Executors.newFixedThreadPool(1);
		//CompletableFuture<Void> voidFuture =
		//		CompletableFuture.supplyAsync(() -> "thenAccept value")
		//				.thenAcceptAsync((value) -> System.out.println("previous value is " + value), pool);
	}

	/****************** 异步任务完成后回调（有参数传递，有返回值） ******************/

	/*
	 * 两个任务之间有参数传递，回调有返回值
	 */
	private static void thenApply() throws Exception {
		CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "one").thenApply((value) -> value + " two");
		System.out.println(future.get());

		//CompletableFuture<String> future = CompletableFuture
		//		.supplyAsync(() -> "one")
		//		.thenApplyAsync((value) -> value + " two", Executors.newFixedThreadPool(1));
		//System.out.println(future.get());
	}

	/****************** 任务异常 ******************/

	private static void exceptionally() throws Exception {
		CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
			int num = RandomUtils.nextInt(1, 10);
			if (num < 6) {
				throw new RuntimeException("exceptionally num " + num);
			}
			return num;
		});

		future.exceptionally((e) -> {
			e.printStackTrace();
			return null;
		});

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

	/****************** 某个任务执行完成后，执行的回调方法，无返回值 ******************/

	private static void whenComplete() throws Exception {
		CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "task value")
				.whenComplete((val, e) -> System.out.println("task complete " + val));
		System.out.println(future.get()); // 返回的是任务的返回值，不是 whenComplete
	}

	/****************** 某个任务执行完成后，执行的回调方法，返回值是任务的返回值 ******************/

	/**
	 * 任务执行完的回调，有自己的返回值
	 */
	private static void handle() throws Exception {
		CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "handle value")
				.handle((val, throwable) -> val + " handle");
		System.out.println(future.get());
	}
}

组合

public class CompletableFutureCombineDemo {

	public static void main(String[] args) throws Exception {
		// AND
		//thenCombine();
		//thenAcceptBoth();
		// runAfterBoth();

		// OR
		//applyToEither();
		//acceptEither();
		//runAfterEither();

		//allOf();
		anyOf();
	}

	/****************** AND 两个任务都执行完后执行 ******************/

	/**
	 * 两个任务的结果作为方法入参，且有返回值
	 */
	private static void thenCombine() throws Exception  {
		CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(() -> "one");
		CompletableFuture<String> twoFuture = CompletableFuture.supplyAsync(() -> "two");

		CompletableFuture<String> threeFuture = twoFuture.thenCombine(oneFuture, (two, one) -> {
			System.out.println(one);
			System.out.println(two);
			return "three";
		});

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

	/**
	 * 两个任务的结果作为方法入参，无返回值
	 */
	private static void thenAcceptBoth() throws Exception {
		CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(() -> "one");
		CompletableFuture<String> twoFuture = CompletableFuture.supplyAsync(() -> "two");

		CompletableFuture<Void> voidFuture = twoFuture.thenAcceptBoth(oneFuture, (s, w) -> {
			System.out.println(s);
			System.out.println(w);
		});
	}

	/**
	 * 无入参，无返回值
	 */
	private static void runAfterBoth() {
		CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(() -> "one");
		CompletableFuture<String> twoFuture = CompletableFuture.supplyAsync(() -> "two");

		twoFuture.runAfterBoth(oneFuture, () -> System.out.println("three"));
	}

	/****************** OR 两个任务有一个执行完执行 ******************/

	private static String sleepAndReturn(String str) {
		try {
			Thread.sleep(500L);
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
		System.out.println(str);
		return str;
	}

	private static String returnStr(String str) {
		System.out.println(str);
		return str;
	}

	/**
	 * 传参、有返回值
	 */
	private static void applyToEither() throws Exception {
		CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(() -> sleepAndReturn("one"));
		CompletableFuture<String> twoFuture = CompletableFuture.supplyAsync(() -> returnStr("two"));

		CompletableFuture<String> threeFuture = twoFuture.applyToEither(oneFuture, (val) -> {
			System.out.println(val);
			return "three";
		});

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

	/**
	 * 传参、无返回值
	 */
	private static void acceptEither() {
		CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(() -> sleepAndReturn("one"));
		CompletableFuture<String> twoFuture = CompletableFuture.supplyAsync(() -> returnStr("two"));

		// void
		CompletableFuture<Void> threeFuture = twoFuture.acceptEither(oneFuture, System.out::println);
	}

	/**
	 * 无传参，无返回值
	 */
	private static void runAfterEither() {
		CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(() -> sleepAndReturn("one"));
		CompletableFuture<String> twoFuture = CompletableFuture.supplyAsync(() -> returnStr("two"));

		// void
		CompletableFuture<Void> threeFuture = twoFuture.runAfterEither(oneFuture, () -> System.out.println("three"));
	}

	/****************** AllOf ******************/

	private static void allOf() throws Exception {
		CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(() -> sleepAndReturn("one"));
		CompletableFuture<String> twoFuture = CompletableFuture.supplyAsync(() -> returnStr("two"));
		CompletableFuture<String> threeFuture = CompletableFuture.supplyAsync(() -> returnStr("three"));

		// void
		CompletableFuture<Void> allFuture = CompletableFuture.allOf(oneFuture, twoFuture, threeFuture);
		allFuture.get();

		/*
		 * Notice that the return type of the CompletableFuture.allOf() is a CompletableFuture<Void>.
		 * The limitation of this method is that it does not return the combined results of all Futures.
		 * Instead, we have to get results from Futures manually.
		 * Fortunately, CompletableFuture.join() method and Java 8 Streams API makes it simple:
		 */
		List<String> resultList = Stream.of(oneFuture, twoFuture, threeFuture).map(CompletableFuture::join).collect(Collectors.toList());
		System.out.println(JSONUtil.toJsonStr(resultList));
	}

	/****************** anyOf ******************/

	private static void anyOf() throws Exception {
		CompletableFuture<String> oneFuture = CompletableFuture.supplyAsync(() -> sleepAndReturn("one"));
		CompletableFuture<String> twoFuture = CompletableFuture.supplyAsync(() -> returnStr("two"));
		CompletableFuture<String> threeFuture = CompletableFuture.supplyAsync(() -> returnStr("three"));

		// object
		CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(oneFuture, twoFuture, threeFuture);
		System.out.println("result is " + anyFuture.get());
	}

	/****************** thenCompose ******************/

	private static void thenCompose() {

	}
}