public class CompletableFutureTest {

    public static void main(String[] args) throws Exception {

        test5();

    }

    /**

     * whenCompleteAsync指的是异步执行传入的BiConsumer

     * whenComplete 指的是同步执行传入的BiConsumer

     */

    public static void  test1() throws ExecutionException, InterruptedException {

        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "hello");

         //future.whenCompleteAsync((v, r) -> {

        future.whenComplete((v, r) -> {

            System.out.println("=========");

            try {

                TimeUnit.SECONDS.sleep();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println("====over=====");

        });

        System.out.println("^^^^^^^^^^");

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

        Thread.currentThread().join();

    }

    /**

     * 同样有异步和同步两种方法,thenApply没有异常处理

     * @throws ExecutionException

     * @throws InterruptedException

     */

    public static void  test2() throws ExecutionException, InterruptedException {

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> "hello")

                .thenApply((s) -> {

                    try {

                        System.out.println("==========");

                        TimeUnit.SECONDS.sleep();

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    System.out.println("====over=====");

                    return s.length();

                });

//              .thenApplyAsync((s) -> {

//                    try {

//                        System.out.println("==========");

//                        TimeUnit.SECONDS.sleep(5);

//                    } catch (InterruptedException e) {

//                        e.printStackTrace();

//                    }

//                    System.out.println("====over=====");

//                    return s.length();

//                });

        System.out.println("^^^^^^^^^^");

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

        Thread.currentThread().join();

    }

    /**

     * handleAsync 有异常处理

     * @throws ExecutionException

     * @throws InterruptedException

     */

    public static void  test3() throws ExecutionException, InterruptedException {

        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> "hello")

                .handleAsync((v, t) -> {

                    return v.length();

                });

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

    }

    /**

     * thenAcceptAsync 直接将上一个的结果进行消费

     * @throws ExecutionException

     * @throws InterruptedException

     */

    public static void  test4() throws ExecutionException, InterruptedException {

        CompletableFuture.supplyAsync(() -> "hello")

                .thenAcceptAsync((x) -> {

                    System.out.println(x);

                });

    }

    /**

     *执行完上一个future后再执行一个runnable

     * @throws ExecutionException

     * @throws InterruptedException

     */

    public static void  test5() throws ExecutionException, InterruptedException {

        CompletableFuture.supplyAsync(() -> "hello")

                .thenRunAsync(() -> {

                    System.out.println("====over===");

                });

    }

}