用过CompletableFuture吗？

1、任务异步化

CompletableFuture允许任务在后台线程中异步执行，不会阻塞主线程。
Demo1：package com.example.demo;

mport java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {
    public static void main(String[] args) {

        CompletableFuture future1 = CompletableFuture.runAsync(() -> {
            System.out.println("执行没有返回值的任务");
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            return "执行有返回值的任务";
        });

        System.out.println(future2.join());
    }

}

打印日志如下：
执行没有返回值的任务
执行有返回值的任务
2、任务依赖

通过CompletableFuture提供的方法，可以方便地对任务进行链式操作，构建复杂的任务依赖关系。

Demo2：
package com.example.demo;

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {
    public static void main(String[] args) {

        CompletableFuture future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("执行第一个任务");
            return 0;
        }).thenRun(() -> {
            System.out.println("执行第二个任务");
        }).thenRun(() -> {
            System.out.println("执行第三个任务");
        });

        CompletableFuture future2 = CompletableFuture.supplyAsync(() -> 5)
            .thenAccept(result -> {
                System.out.println("任务执行结果 = " + result * 3);
            }).thenAccept(result -> {
                System.out.println("任务执行完成");
            });

        CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> 5)
                .thenApply(result -> result * 3)
                .thenApply(result -> result + 3);

        System.out.println(future3.join());
    }

}

如 Demo2 所示，我们可以通过thenRun() 、thenAccept()、thenApply() 方法将前后任务连接起来，形成前后有依赖的任务链。其中：
thenRun(Runnable runnable): 对异步任务的结果进行操作，不能传入参，也没有返回值。
thenAccept(Consumer consumer): 对异步任务的结果进行消费，可以传入参，但没有返回值。
thenApply(Function function): 对异步任务的结果进行转换，可传入参，返回一个新的CompletableFuture。
打印日志如下：

执行第一个任务
执行第二个任务
执行第三个任务
任务执行结果 = 15
任务执行完成
18

3、任务并行取第一个

 
CompletableFuture支持多个任务的并行执行，且返回第一个最先完成的任务结果。

Demo3：

package com.example.demo;

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {

    public static void main(String[] args) {

        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "朋友小王去你家送药");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "朋友小张去你家送药");

        CompletableFuture<Object> anyFutures = CompletableFuture.anyOf(future1, future2);
        System.out.println(anyFutures.join());
    }
}

如 Demo3 所示，我们可以通过 anyOf() 方法来进行实现。需要注意的是，如果最快完成的任务出现异常，则返回的CompletableFuture 执行 get() 方法时会抛出异常。

4、任务并行取全部

CompletableFuture支持多个任务的并行执行，等到所有结果产生后，再进行汇总计算。

Demo4：

package com.example.demo;

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {

public static void main(String[] args) {

    CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 15);
    CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 10);

    CompletableFuture<Integer> allFutures = CompletableFuture.allOf(future1, future2).thenApply(res -> {
        return future1.join()  + future2.join();
    });
    System.out.println(allFutures.join());
}

}
如 Demo4 所示，我们可以通过 allOf() 方法来进行实现。需要注意的是，如果任意一个任务出现异常，则返回的CompletableFuture 执行 get() 方法时会抛出异常。

5、任务回调

CompletableFuture支持某个任务执行完成后，去继续执行一个回调方法。

Demo5：

package com.example.demo;

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {

    public static void main(String[] args) {

        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            return "返回任务结果";
        });

        CompletableFuture<String> future1Callback = future1.whenComplete((result, throwable) -> {
            System.out.println("执行回调任务");
        });

        System.out.println(future1Callback.join());

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            return "返回任务结果";
        });
        CompletableFuture<String> future2Callback = future2.handle((result, throwable) -> {
            return "返回回调结果";
        });
        System.out.println(future2Callback.join());
    }
}