CompletableFuture

文档地址：
 https://www.matools.com/api/java8
 https://blog.csdn.net/sl1992/article/details/100677099

package com.example.netty.async;

import java.util.concurrent.*;

/**
 * @author luliang
 * @date 2021-01-25 14:21
 * CompletableFuture；异步执行
 * 文档地址：
 * https://www.matools.com/api/java8
 * https://blog.csdn.net/sl1992/article/details/100677099
 */
public class CompletableFutureTest {

    //一、CompletableFuture的静态方法
    public void staticMethod() {
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        //1、异步执行，有返回值，使用ForkJoinPool.commonPool()中的线程
        CompletableFuture.supplyAsync(() -> null);
        //2、异步执行，有返回值，使用Executors中的线程
        CompletableFuture.supplyAsync(() -> null, executorService);
        //3、异步执行，无返回值，使用ForkJoinPool.commonPool()中的线程
        CompletableFuture.runAsync(() -> {
        });
        //4、异步执行，无返回值，使用Executors中的线程
        CompletableFuture.runAsync(() -> {
        }, executorService);
        //3、使用给定值进行操作
        CompletableFuture.completedFuture(1).thenApply((s) -> s + 3);
        //4、当所有给定的CompletableFutures完成时
        CompletableFuture.allOf();
        //5、当任何一个给定的CompletableFutures完成
        CompletableFuture.anyOf();
    }

    //二、普通方法
    public static void method(CompletableFuture<Integer> futureA, CompletableFuture<Integer> futureB) throws Exception {
        /**
         * 哪个线程跑的最快用那个，无返回值
         * 1、supplyAsync与acceptEitherAsync（默认的线程池）与acceptEitherAsync（给定的线程池）
         */
        CompletableFuture<Void> futureVoid = futureB.acceptEitherAsync(futureA, (s) -> System.out.println(s));

        /**
         * 哪个线程跑的最快用那个，有返回值
         * 2、applyToEither与applyToEitherAsync（默认的线程池）与applyToEitherAsync（给定的线程池）
         */
        CompletableFuture<Integer> futureC = futureB.applyToEitherAsync(futureA, (o -> o));

        /**
         * 3、终止任务，如果未完成，抛出CancellationException
         */
        //futureB.cancel(true);
        /**
         * 4、终止任务，返回给定的值
         */
        futureB.complete(99);
        /**
         * 5、终止任务，如果未完成，调用 get()和相关方法时抛出指定异常信息
         */
        futureB.completeExceptionally(new Exception("结束异常"));
        /**
         * 6、如果CompletableFuture出现异常，则执行exceptionally，否则正常返回
         * exceptionally
         */
        CompletableFuture<Integer> futureAll = CompletableFuture.supplyAsync(() -> 1 / 1).exceptionally((t) -> {
            System.out.println("异常信息" + t);
            return 10;
        });
        /**
         * 7、获取执行结果，会阻塞，抛出异常
         */
        futureB.get();
        /**
         * 8、获取执行结果，设置等待时间（超时时间）
         */
        futureB.get(1, TimeUnit.MINUTES);
        /**
         * 9、获取执行结果，如果执行完成则返回结果或抛出异常，否则返回给定值
         */
        futureA.getNow(100);
        /**
         *10、将CompletableFuture执行结果或异常信息作为参数，进行执行
         * handle、handleAsync（默认线程池）、handleAsync（自定义线程池）
         */
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 10 / 0);
        future.handle((s, t) -> {
            System.out.println("参数" + s);
            System.out.println("异常信息" + t);
            return null;
        });
        /**
         * 11、如果以任何方式完成，返回true，否则false
         */
        futureA.isDone();
        /**
         * 12、在正常完成之前被取消，则返回 true
         */
        futureA.isCancelled();
        /**
         * 13、以任何方式异常完成包括取消，则返回true
         */
        futureA.isCompletedExceptionally();
        /**
         * 14、获取执行结果，没有检查异常，不会强制抛出异常
         */
        Integer join = futureA.join();
        /**
         * 15、强制返回结果，不管是否执行完成
         */
        futureA.obtrudeValue(100);
        /**
         * 16、强制抛出异常，无论是否执行完成
         */
        futureA.obtrudeException(new Exception("异常"));
        /**
         *17、两个异步线程都执行完毕后，执行线程C
         * runAfterBoth、runAfterBothAsync（默认线程池）、runAfterBothAsync（自定义线程池）
         */
        futureA.runAfterBoth(futureB, () -> {
        });
        /**
         * 18、两个线程有任何一个执行完毕，执行线程C
         * runAfterEither、runAfterEitherAsync（默认线程池）、runAfterEitherAsync（自定义线程池）
         */
        futureA.runAfterEither(futureB, () -> {
        });
        /**
         * 19、当此阶段正常完成时，将以该阶段的结果作为参数执行，无返回值
         * thenAccept、thenAcceptAsync（默认线程池）、thenAcceptAsync（自定义线程池）
         */
        futureA.thenAccept((v) -> System.out.println());
        /**
         * 20、当此阶段正常完成时，将以该阶段的结果作为参数执行，有返回值
         * thenApply、thenApplyAsync（默认线程池）、thenApplyAsync（自定义线程池）
         */
        futureA.thenApply((v) -> v);
        /**
         * 21、两个线程执行完毕后，将两个线程的结果作为参数进行执行，无返回值
         * thenAcceptBoth、thenAcceptBothAsync（默认线程池）、thenAcceptBothAsync（自定义线程池）
         */
        futureA.thenAcceptBoth(futureB, (f1, f2) -> {
        });
        /**
         * 22、两个线程执行完毕后，将亮哥哥线程的结果作为参数进行执行，有返回值
         */
        futureA.thenCombine(futureB, (f1, f2) -> null);
        /**
         * 23、此阶段正常完成时，将以该阶段的结果作为参数执行，有返回值
         * thenCompose、thenComposeAsync、thenComposeAsync
         * 不指定泛型，类型为Object，
         */
        futureA.thenCompose((f1) -> null);
        /**
         * 22、正常完成时，执行此操作，无返回值
         * thenRun、thenRunAsync、thenRunAsync
         */
        futureA.thenRun(() -> {
        });
        /**
         * 23、返回此CompletableFuture
         */
        futureA.toCompletableFuture();
        /**
         * 24、当此阶段完成时，以此阶段的结果（如果没有则为null）和异常（如果没有则为null）作为参数来调用给定操作。
         * 返回阶段在操作返回时完成。如果提供的操作本身遇到异常，那么除非此阶段也异常完成，否则返回的阶段将异常完成。
         */
        futureA.whenComplete((f1, t) -> {
        });
    }

    public static void main(String[] args) throws Exception {
        CompletableFuture<Integer> futureA = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("A执行完毕" + Thread.currentThread().getId());
            return 1;
        });
        CompletableFuture<Integer> futureB = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("B执行完毕" + Thread.currentThread().getId());
            return 2;
        });

        method(futureA, futureB);
        while (true) {
        }
    }
}