谷粒商城篇章6 ---- P193-P210 ---- 异步&线程池&商品详情【分布式高级篇三】


public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("main...start...");
        // 1. 继承Thread类
        Thread01 thread01 = new Thread01();
        thread01.start(); // 启动线程
        System.out.println("main...end...");
    }
 
    public static class Thread01 extends Thread{
        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果："+i);
        }
    }
}

测试结果：

1.1.2 实现 Runnable 接口


public class ThreadTest {
    
    public static void main(String[] args) {
        System.out.println("main...start...");
         // 1. 继承Thread类
        //Thread01 thread01 = new Thread01();
        //thread01.start(); // 启动线程
 
        // 2. 实现Runnable接口
        Runnable01 runnable01 = new Runnable01();
        new Thread(runnable01).start();
 
        System.out.println("main...end...");
    }
 
    public static class Thread01 extends Thread{
        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果："+i);
        }
    }
 
    public static class Runnable01 implements Runnable{
 
        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果："+i);
        }
    }
}

1.1.3 实现 Callable 接口 + FutureTask

FutureTask的get()方法，阻塞式等待整个线程的执行完成，获取线程执行返回结果。


public class ThreadTest {
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main...start...");
        // 1. 继承Thread类
        //Thread01 thread01 = new Thread01();
        //thread01.start(); // 启动线程
 
        // 2. 实现Runnable接口
        //Runnable01 runnable01 = new Runnable01();
        //new Thread(runnable01).start();
 
        // 3. 实现Callable接口+FutureTask （可以拿到返回结果，可以处理异常）
        Callable01 callable01 = new Callable01();
        FutureTask futureTask = new FutureTask<>(callable01);
        new Thread(futureTask).start();
        // 阻塞式等待整个线程执行完成，获取线程执行返回结果
        Integer integer = futureTask.get();
 
        System.out.println("main...end..."+integer );
    }
 
    public static class Thread01 extends Thread{
        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果："+i);
        }
    }
 
    public static class Runnable01 implements Runnable{
 
        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果："+i);
        }
    }
 
    public static class Callable01 implements Callable{
 
        @Override
        public Integer call() throws Exception {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果："+i);
            return i;
        }
    }
}

注意：

Future可以获取异步执行结果；

FutureTask继承了Runnable接口。

1.1.4 线程池


public class ThreadTest {
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main...start...");
        // 1. 继承Thread类
        //Thread01 thread01 = new Thread01();
        //thread01.start(); // 启动线程
 
        // 2. 实现Runnable接口
        //Runnable01 runnable01 = new Runnable01();
        //new Thread(runnable01).start();
 
        // 3. 实现Callable接口+FutureTask （可以拿到返回结果，可以处理异常）
        //Callable01 callable01 = new Callable01();
        //FutureTask futureTask = new FutureTask<>(callable01);
        //new Thread(futureTask).start();
         阻塞式等待整个线程执行完成，获取线程执行返回结果
        //Integer integer = futureTask.get();
 
        // 在以后的业务代码里面，以上三种启动线程的方式都不用，因为频繁的创建和销毁线程耗费系统资源。【将所有的多线程异步任务都交给线程池执行】
        //new Thread(()-> System.out.println("hello")).start();
 
        // 4. 线程池  给线程池直接提交业务
 
        // 当前系统中池只有一两个（例如：核心业务/非核心业务），每个异步任务，提交给线程池让它自己去执行就行
        executorService.execute(new Runnable01());
        System.out.println("main...end...");
    }
 
    public static class Thread01 extends Thread{
        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果："+i);
        }
    }
 
    public static class Runnable01 implements Runnable{
 
        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果："+i);
        }
    }
 
    public static class Callable01 implements Callable{
 
        @Override
        public Integer call() throws Exception {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("运行结果："+i);
            return i;
        }
    }
}

1.1.5 以上 4 种方式总结：


区别：
1、2不能得到返回值；3可以获取返回值
1、2、3都不能控制资源
4可以控制资源，性能稳定

注意：

1. 在以后的业务代码里面，以上三种启动线程的方式都不用，因为频繁的创建和销毁线程耗费系统资源，可能导致服务器资源耗尽。【将所有的多线程异步任务都交给线程池执行】

2. 当前系统中池只有一两个（例如：核心业务/非核心业务），每个异步任务，提交给线程池让它自己去执行就行

1.2 线程池详解

1.2.1 初始化线程池的 2 种方式

1.2.1.1 使用 Executors 创建

ExecutorService executorService = Executors.newFixedThreadPool(10);

线程池执行任务的两种方式：

executorService.execute(new Runnable01());
Future submit = executorService.submit(new Runnable01());

区别：

execute：参数只能是Runnable，没有返回值。
submit：参数可以是Runnable、Callable，返回值是Future。

1.2.1.2 使用 ThreadPoolExecutor 创建


ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
            200,
            10,
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100000),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy());

1.2.1.2.1 ThreadPoolExecutor 线程池的七大参数

corePoolSize：核心线程数【一直存在除非(allowCoreThreadTimeOut)】，线程池创建好后就准备就绪，等待任务。
maximumPoolSize：最大线程数，控制资源。
keepAliveTime：存活时间。如果当前的线程数大于核心线程数，只要线程空闲大于指定的keepAliveTime，就会释放空闲的线程【maximumPoolSize-corePoolSize】。
unit：存活时间的时间单位。
workQueue：阻塞队列。如果当前对线程的需求超过核心线程数，就会将多余的任务放到阻塞队列。如果有空闲的线程，就会去队列里取出新的任务继续执行。
threadFactory：创建线程的工厂。
handler：拒绝策略。提交给线程池的任务量超过最大线程池大小+队列长度，按照我们指定的拒绝策略拒绝执行任务。
- ThreadPoolExecutor.AbortPolicy：抛出 RejectedExecutionException来拒绝新任务的处理。
- ThreadPoolExecutor.CallerRunsPolicy：调用执行自己的线程运行任务。
- ThreadPoolExecutor.DiscardPolicy：不处理新任务，直接丢弃掉。
- ThreadPoolExecutor.DiscardOldestPolicy：此策略将丢弃最早的未处理的任务请求。

1.2.1.2.2 运行流程

        1、线程池创建，准备好core数量的核心线程，准备接受任务。
        2、core 满了，就将再进来的任务放入阻塞队列中。空闲的 core 就会自己去阻塞队列获取任务执行。
        3、阻塞队列满了，就直接开新线程执行，最大只能开到 max 指定的数量
        4、如果线程数开到了 max 的数量，还有新任务进来，就会使用 RejectedExecutionHandler拒绝任务。
        5、max 都执行好了。 Max-core 数量空闲的线程会在 keepAliveTime 指定的时间后自动销毁。最终保持到 core 大小。

1.2.1.2.3 线程池面试题

问题：一个线程池 core 7； max 20 ， queue： 50， 100 并发进来怎么分配的；
答案：先有 7 个能直接得到执行，接下来 50 个进入队列排队，在多开 13 个继续执行。现在 70 个被安排上了。剩下 30 个默认拒绝策略。

1.2.2 常见的 4 种线程池

newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool：创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

1.2.3 使用线程池的好处

降低资源的消耗：通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗。
提高响应速度：因为线程池中的线程数没有超过线程池的最大上限时，有的线程处于等待分配任务的状态，当任务来时无需创建新的线程就能执行。
提高线程的可管理性：线程池会根据当前系统特点对池内的线程进行优化处理，减少创建和销毁线程带来的系统开销。无限的创建和销毁线程不仅消耗系统资源，还降低系统的稳定性，使用线程池进行统一分配。

1.3 CompletableFuture异步编排

在 Java 8 中, 新增加了一个包含 50 个方法左右的类: CompletableFuture，提供了非常强大的Future 的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合 CompletableFuture 的方法。CompletableFuture 类实现了 Future 接口，所以你还是可以像以前一样通过`get`方法阻塞或者轮询的方式获得结果，但是这种方式不推荐使用。

CompletableFuture 和 FutureTask 同属于 Future 接口的实现类，都可以获取线程的执行结果。

1.3.1 启动异步任务

CompletableFuture 提供了四个静态方法来创建一个异步操作。


public static CompletableFuture runAsync(Runnable runnable)
public static CompletableFuture runAsync(Runnable runnable,Executor executor)
public static  CompletableFuture supplyAsync(Supplier supplier)
public static  CompletableFuture supplyAsync(Supplier supplier,Executor executor)

注意：

（1）runAsync都是没有返回结果的，supplyAsync都是可以获取返回结果的；

（2）可以传入自定义的线程池，否则就用默认的线程池；

（3）Async代表异步方法。

1.3.1.1 runAsync没有返回值


public static void main(String[] args) {
     System.out.println("main...start...");
     CompletableFuture future = CompletableFuture.runAsync(() -> {
          System.out.println("当前线程：" + Thread.currentThread().getId());
          int i = 10 / 2;
          System.out.println("运行结果：" + i);
     }, executorService);
     
     System.out.println("main...end...");
}

测试结果：

1.3.1.2 supplyAsync有返回值


public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main...start...");
    CompletableFuture future = CompletableFuture.supplyAsync(() -> {
        System.out.println("当前线程：" + Thread.currentThread().getId());
        int i = 10 / 2;
        System.out.println("运行结果：" + i);
        return i;
    }, executorService);
    Integer integer = future.get();
    System.out.println("main...end..."+integer);
}

测试结果：

1.3.2 完成回调与异常感知


public CompletableFuture whenComplete(BiConsumersuper T, ? super Throwable> action)
public CompletableFuture whenCompleteAsync(BiConsumersuper T, ? super Throwable> action)
public CompletableFuture whenCompleteAsync(BiConsumersuper T, ? super Throwable> action, Executor executor)
 
public CompletableFuture exceptionally(Function fn)

whenComplete可以处理正常和异常的结果， exceptionally 处理异常情况。

whenComplete 和 whenCompleteAsync 的区别：

whenComplete：是执行当前任务的线程执行继续执行 whenComplete 的任务。
whenCompleteAsync：是执行把 whenCompleteAsync 这个任务继续提交给线程池
来进行执行。

注意：方法不以 Async 结尾，意味着 Action 使用相同的线程执行，而 Async 可能会使用其他线程执行（如果是使用相同的线程池，也可能会被同一个线程选中执行）

1.3.2.1 完成回调 whenComplete

无异常情况


public class ThreadTest {
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);
 
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main...start...");
        //CompletableFuture future = CompletableFuture.runAsync(() -> {
        //    System.out.println("当前线程：" + Thread.currentThread().getId());
        //    int i = 10 / 2;
        //    System.out.println("运行结果：" + i);
        //}, executorService);
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 1;
            System.out.println("运行结果：" + i);
            return i;
        }, executorService).whenComplete((result,exception)->{
            // 可以感知到异常，但无法修改返回数据
            System.out.println("异步任务完成了...返回值为："+result+";异常为："+exception);
        });
        //Integer integer = future.get();
        System.out.println("main...end...");
    }
}

有异常情况

将 int i = 10/1; 改为 int i = 10/0;

1.3.2.2 异常感知 exceptionally

无异常情况（不会进入exceptionally）


public class ThreadTest {
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);
 
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main...start...");
        //CompletableFuture future = CompletableFuture.runAsync(() -> {
        //    System.out.println("当前线程：" + Thread.currentThread().getId());
        //    int i = 10 / 2;
        //    System.out.println("运行结果：" + i);
        //}, executorService);
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果：" + i);
            return i;
        }, executorService).whenComplete((result,exception)->{
            // 可以感知到异常，但无法修改返回数据
            System.out.println("异步任务完成了...返回值为："+result+";异常为："+exception);
        }).exceptionally(throwable -> {
            // 可以感知异常，同时返回默认值
            return 10;
        });
        Integer integer = future.get();
        System.out.println("main...end..."+integer);
    }
}

有异常情况

将 int i = 10/2; 改为 int i = 10/0;

1.3.3 handle 最终处理

一般用handle，因为whencomplete如果异常不能给定默认返回结果，需要再调用exceptionally，而handle可以。

handle方法作用：获得前一任务的返回值【handleAsync可以是异步执行的】，也可以处理上一任务的异常，调用exceptionally修改前一任务的返回值【只有在异常情况时给一个默认返回值】而handle方法可以简化操作。

无异常情况


public class ThreadTest {
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);
 
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main...start...");
        //CompletableFuture future = CompletableFuture.runAsync(() -> {
        //    System.out.println("当前线程：" + Thread.currentThread().getId());
        //    int i = 10 / 2;
        //    System.out.println("运行结果：" + i);
        //}, executorService);
        /**
         * 方法执行完成后的感知
         */
        //CompletableFuture future = CompletableFuture.supplyAsync(() -> {
        //    System.out.println("当前线程：" + Thread.currentThread().getId());
        //    int i = 10 / 2;
        //    System.out.println("运行结果：" + i);
        //    return i;
        //}, executorService).whenComplete((result,exception)->{
        //    // 可以感知到异常，但无法修改返回数据
        //    System.out.println("异步任务完成了...返回值为："+result+";异常为："+exception);
        //}).exceptionally(throwable -> {
        //    // 可以感知异常，同时返回默认值
        //    return 10;
        //});
        /**
         *  方法执行完成后的处理
         */
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 4;
            System.out.println("运行结果：" + i);
            return i;
        }).handle((res, thr) -> {
            if (res != null) {
                return res * 2;
            }
            if (thr != null) {
                return 10;
            }
            return 0;
        });
        // R apply(T t, U u);
        Integer integer = future.get();
        System.out.println("main...end..."+integer);
    }
}

有异常情况

将 int i = 10/4; 改为 int i = 10/0;

1.3.4 线程串行化


public  CompletableFuture thenApply(Functionsuper T,? extends U> fn)
public  CompletableFuture thenApplyAsync(Functionsuper T,? extends U> fn)
public  CompletableFuture thenApplyAsync(Functionsuper T,? extends U> fn, Executor executor)
 
public CompletableFuture thenAccept(Consumersuper T> action)
public CompletableFuture thenAcceptAsync(Consumersuper T> action)
public CompletableFuture thenAcceptAsync(Consumersuper T> action,Executor executor)
 
public CompletableFuture thenRun(Runnable action)
public CompletableFuture thenRunAsync(Runnable action)
public CompletableFuture thenRunAsync(Runnable action,Executor executor)

thenApply 方法：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前
任务的返回值。
thenAccept 方法：消费处理结果。接收任务的处理结果，并消费处理，无返回结果。
thenRun 方法：只要上面的任务执行完成，就开始执行 thenRun，只是处理完任务后，执行
thenRun 的后续操作
带有 Async 默认是异步执行的。同之前。
以上都要前置任务成功完成。
Function
T：上一个任务返回结果的类型。
U：当前任务的返回值类型。

1.3.4.1 thenRunAsync


public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main...start...");
    CompletableFuture.supplyAsync(() -> {
        System.out.println("当前线程：" + Thread.currentThread().getId());
        int i = 10 / 4;
        System.out.println("运行结果：" + i);
        return i;
    }).thenRunAsync(()->{
        // 不接收上一步结果，无返回值
        System.out.println("任务2启动了...");
    },executorService);
    System.out.println("main...end...");
}

执行结果：

1.3.4.2 thenAcceptAsync


public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main...start...");
    CompletableFuture.supplyAsync(() -> {
        System.out.println("当前线程：" + Thread.currentThread().getId());
        int i = 10 / 4;
        System.out.println("运行结果：" + i);
        return i;
    }).thenAcceptAsync(res -> {
        // thenRunAsync：不接收上一步结果，无返回值
        // thenAcceptAsync：接收上一步结果，无返回值  void accept(T t);
        System.out.println("任务2启动了..." + res);
    }, executorService);
    System.out.println("main...end...");
}

执行结果：

1.3.4.3 thenApplyAsync


public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main...start...");
    CompletableFuture future = CompletableFuture.supplyAsync(() -> {
        System.out.println("当前线程：" + Thread.currentThread().getId());
        int i = 10 / 4;
        System.out.println("运行结果：" + i);
        return i;
    }).thenApplyAsync(res -> {
        // thenRunAsync：不接收上一步结果，无返回值
        // thenAcceptAsync：接收上一步结果，无返回值  void accept(T t);
        // thenApplyAsync：接收上一步结果，有返回值  R apply(T t);
        System.out.println("任务2启动了..." + res);
        return "Hello" + res;
    }, executorService);
    System.out.println("main...end..."+future.get());
}

执行结果：

1.3.5 两个任务组合 - 都要完成


public  CompletableFuture thenCombine(CompletionStage other,
BiFunctionsuper T,? super U,? extends V> fn)
public  CompletableFuture thenCombineAsync(CompletionStage other,
BiFunctionsuper T,? super U,? extends V> fn)
public  CompletableFuture thenCombineAsync(CompletionStage other,
BiFunctionsuper T,? super U,? extends V> fn, Executor executor)
 
public  CompletableFuture thenAcceptBoth(CompletionStage other,
BiConsumersuper T, ? super U> action)
public  CompletableFuture thenAcceptBothAsync(CompletionStage other,
BiConsumersuper T, ? super U> action)
public  CompletableFuture thenAcceptBothAsync(CompletionStage other,
BiConsumersuper T, ? super U> action, Executor executor)
 
public CompletableFuture runAfterBoth(CompletionStage other,Runnable action)
public CompletableFuture runAfterBothAsync(CompletionStage other,Runnable action)
public CompletableFuture runAfterBothAsync(CompletionStage other,Runnable action,
Executor executor)

两个任务必须都完成，触发该任务。
thenCombine：组合两个 future，获取两个 future 的返回结果，并返回当前任务的返回值
thenAcceptBoth：组合两个 future，获取两个 future 任务的返回结果，然后处理任务，没有
返回值。
runAfterBoth：组合两个 future，不需要获取 future 的结果，只需两个 future 处理完任务后，
处理该任务。

1.3.5.1 runAfterBothAsync


public class ThreadTest {
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);
 
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main...start...");
        /**
         * 两个任务组合-都要完成
         */
        CompletableFuture future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程："+Thread.currentThread().getId());
            int i = 10/4;
            System.out.println("任务1结束。。。");
            return i;
        }, executorService);
        CompletableFuture future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程："+Thread.currentThread().getId());
            System.out.println("任务2结束。。。");
            return "Hello";
        }, executorService);
        future01.runAfterBothAsync(future02,()->{
            System.out.println("任务3开始");
        },executorService);
        System.out.println("main...end...");
    }
}

执行结果：

1.3.5.2 thenAcceptBothAsync


public class ThreadTest {
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);
 
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main...start...");
        /**
         * 两个任务组合-都要完成
         */
        CompletableFuture future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程："+Thread.currentThread().getId());
            int i = 10/4;
            System.out.println("任务1结束。。。");
            return i;
        }, executorService);
        CompletableFuture future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程："+Thread.currentThread().getId());
            System.out.println("任务2结束。。。");
            return "Hello";
        }, executorService);
        //future01.runAfterBothAsync(future02,()->{
        //    System.out.println("任务3开始");
        //},executorService);
        future01.thenAcceptBothAsync(future02,(f1,f2)->{
            //void accept(T t, U u);
            System.out.println("任务3开始。。。之前的结果："+f1+"->"+f2);
        },executorService);
        System.out.println("main...end...");
    }
}

执行结果：

1.3.5.3 thenCombineAsync


public class ThreadTest {
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);
 
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main...start...");
        /**
         * 两个任务组合-都要完成
         */
        CompletableFuture future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程："+Thread.currentThread().getId());
            int i = 10/4;
            System.out.println("任务1结束。。。");
            return i;
        }, executorService);
        CompletableFuture future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程："+Thread.currentThread().getId());
            System.out.println("任务2结束。。。");
            return "Hello";
        }, executorService);
        //future01.runAfterBothAsync(future02,()->{
        //    System.out.println("任务3开始");
        //},executorService);
        //future01.thenAcceptBothAsync(future02,(f1,f2)->{
        //    //void accept(T t, U u);
        //    System.out.println("任务3开始。。。之前的结果："+f1+"->"+f2);
        //},executorService);
        CompletableFuture future = future01.thenCombineAsync(future02, (f1, f2) -> {
            return f1 + "->" + f2 + "->相柳"; // R apply(T t, U u);
        }, executorService);
        System.out.println("main...end..."+future.get());
    }
}

执行结果：

1.3.6 两个任务组合 - 一个完成


public  CompletableFuture applyToEither(CompletionStage other, Functionsuper T, U> fn)
public  CompletableFuture applyToEitherAsync(CompletionStage other, Functionsuper T, U> fn)
public  CompletableFuture applyToEitherAsync(CompletionStage other, Functionsuper T, U> fn,Executor executor)
 
public CompletableFuture acceptEither(CompletionStage other, Consumersuper T> action)
public CompletableFuture acceptEitherAsync(CompletionStage other, Consumersuper T> action)
public CompletableFuture acceptEitherAsync(CompletionStage other, Consumersuper T> action,Executor executor)
 
public CompletableFuture runAfterEither(CompletionStage other,Runnable action)
public CompletableFuture runAfterEitherAsync(CompletionStage other,Runnable action)
public CompletableFuture runAfterEitherAsync(CompletionStage other,Runnable action,Executor executor)

当两个任务中，任意一个 future 任务完成的时候，执行任务。
applyToEither：两个任务有一个执行完成，获取它的返回值，处理任务并有新的返回值。
acceptEither：两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值。
runAfterEither：两个任务有一个执行完成，不需要获取 future 的结果，处理任务，也没有返
回值。

1.3.6.1 runAfterEitherAsync

线程1执行完成，线程2睡了3秒，达成runAfterEitherAsync执行条件


public class ThreadTest {
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);
 
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main...start...");
        CompletableFuture future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程："+Thread.currentThread().getId());
            int i = 10/4;
            System.out.println("任务1结束。。。");
            return i;
        }, executorService);
        CompletableFuture future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程："+Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务2结束。。。");
            return "Hello";
        }, executorService);
  
        /**
         * 两个任务，只要有一个完成，我们就执行任务3
         */
        future01.runAfterEitherAsync(future02,()->{
            System.out.println("任务3开始。。。之前的结果：");
        },executorService);
        System.out.println("main...end...");
    }
}

执行结果：

1.3.6.2 acceptEitherAsync

两个任务的返回值类型要一致，这里全改为Object


public class ThreadTest {
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);
 
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main...start...");
        CompletableFuture