CompletableFuture异步编排（两任务组合——其中一个任务执行）

runAfterEither方法： 两个任务有一个执行完成，不需要获取future的结果，处理任务，也没有返回值。

代码示例

package com.xz.thread.day1;
import lombok.SneakyThrows;
import java.util.concurrent.*;
/**
 * @description: 两任务组合（一个任务执行）
 *              runAfterEither 两个任务有一个执行完成，不需要获取future的结果，处理任务，也没有返回值。
 * @author: xz
 * @create: 2022-08-23
 */
public class Test14 {
    /**
     * 定义线程池
     */
    public static ExecutorService service = Executors.newFixedThreadPool(3);

    @SneakyThrows
    public static void main(String[] args)  {
        System.out.println("main start ...");

        CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("开启异步任务1...");
            int i = 10 / 1;
            return i;
        }, service);

        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("开启异步任务2...");
            return "hello world!";
        }, service);

        future1.runAfterEitherAsync(future2, () -> {
            System.out.println("任务3 启动了....");
        }, service);

        System.out.println("main end ...");
    }
}

输出结果

由上述输出结果可知，任务1执行完成后，任务3不需要等待任务2执行完成，即可启动任务3。但是使用runAfterEitherAsync不能感知任务的返回值，自身也无返回值。

acceptEither方法： 两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值。

代码示例

package com.xz.thread.day1;
import lombok.SneakyThrows;
import java.util.concurrent.*;
/**
 * @description: 两任务组合（一个任务执行）
 *              acceptEither 两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值。
 * @author: xz
 * @create: 2022-08-23
 */
public class Test15 {
    /**
     * 定义线程池
     */
    public static ExecutorService service = Executors.newFixedThreadPool(5);

    @SneakyThrows
    public static void main(String[] args) {
        System.out.println("main start ...");

        CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("开启异步任务1...");
            int i = 10 / 1;
            return i;
        }, service);

        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("开启异步任务2...");
            return 20;
        }, service);

        future1.acceptEitherAsync(future2, (res) -> {
            System.out.println("任务3 启动了...., 任务结果是：" + res);
        }, service);

        System.out.println("main end ...");
    }
}

输出结果

由上述输出结果可知，可以获取任务1的执行结果，但不返回执行结果。

applyToEither方法： 两个任务有一个任务执行完成，获取它的返回值，处理任务并有新的返回值。

代码示例

package com.xz.thread.day1;
import lombok.SneakyThrows;
import java.util.concurrent.*;
/**
 * @description:
 *          ApplyToEither 两个任务有一个任务执行完成，获取它的返回值，处理任务并有新的返回值。
 * @author: xz
 * @create: 2022-08-23
 */
public class Test16 {
    /**
     * 定义线程池
     */
    public static ExecutorService service = Executors.newFixedThreadPool(3);

    @SneakyThrows
    public static void main(String[] args){
        System.out.println("main start ...");

        CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("开启异步任务1...");
            int i = 10 / 1;
            return i;
        }, service);

        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("开启异步任务2...");
            return 20;
        }, service);

        CompletableFuture stringCompletableFuture = future1.applyToEitherAsync(future2, (res) -> {
            System.out.println("任务3 启动了...., 上个任务结果是：" + res);
            return "我是任务3的返回值， 上个任务的执行结果是：" + res;
        }, service);
        System.out.println("======"+stringCompletableFuture.get());

        System.out.println("main end ...");
    }
}

输出结果

由上述输出结果可知，可以获取任务1的执行结果，并且返回执行结果。