Java8 CompletableFuture 異步執(zhí)行操作

更新時間：2021年06月22日 18:02:04 作者：ACGkaka_

CompletableFuture是java8提供的基于異步操作的封裝，日常開發(fā)中經(jīng)常會用到，接下來通過本文給大家介紹Java8 CompletableFuture 異步執(zhí)行操作，感興趣的朋友一起看看吧

1.簡介

CompletableFuture 是 JDK8 提供的一個異步執(zhí)行工具。

示例1：

public static void main(String[] args) throws ExecutionException, InterruptedException {
    CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
        for (int i = 0; i < 3; i++) {
            System.out.println(i);
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException ignored) {
            }
        }
        System.out.println("Future Finished.");
    });
    System.out.println("Main Thread Finished.");
    future.get();
}

輸出結果1：

2.異步執(zhí)行

CompletableFuture 提供了兩個方法用于異步執(zhí)行：

CompletableFuture.runAsync，沒有返回值；

CompletableFuture.supplyAsync，有返回值。

示例：

public static void main(String[] args) throws ExecutionException, InterruptedException {
    // runAsync 沒有返回值
    CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> System.out.println("future1 executed."));
    // supplyAsync 有返回值
    CompletableFuture<Object> future2 = CompletableFuture.supplyAsync(() -> {
        System.out.println("future2 executed.");
        return "result";
    });

    System.out.println("future1.get(): " + future1.get());
    System.out.println("future2.get(): " + future2.get());
}

輸出結果：

3.守護線程

CompletableFuture返回的Future默認為守護線程，如果不調(diào)用get()獲取結果，主線程結束后會自動結束。主要有以下4種情景：

情景1：執(zhí)行時間 > 主線程時間，異步線程會執(zhí)行；
情景2：執(zhí)行時間 > 主線程，是守護線程，會被殺死，異步線程不會執(zhí)行；
情景3：執(zhí)行時間 > 主線程，但是不是守護線程，不會被殺死，異步線程會執(zhí)行；
情景4： ExecutorService.submit()，默認不是守護線程，不會被殺死，異步線程會執(zhí)行。

示例：

public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(2);
    // 1.執(zhí)行時間 < 主線程，會打印
    CompletableFuture<Void> future1 = CompletableFuture.runAsync(() ->
		System.out.println("Thread1 是否為守護線程 : " + Thread.currentThread().isDaemon()));

    // 2.執(zhí)行時間 > 主線程，是守護線程，會被殺死，不會打印
    CompletableFuture.runAsync(() -> {
        try {
            Thread.sleep(3000L);
            System.out.println("Thread2 是否為守護線程 : " + Thread.currentThread().isDaemon());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }});

    // 3.執(zhí)行時間 > 主線程，但是不是守護線程，不會被殺死，會打印
    CompletableFuture.runAsync(() -> {
        try {
            Thread.sleep(1000L);
            System.out.println("Thread3 等待1秒");
            System.out.println("Thread3 是否為守護線程 : " + Thread.currentThread().isDaemon());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }}, executorService);

    // 4.ExecutorService.submit()，默認不是守護線程，不會被殺死，會打印。
    executorService.submit(() -> {
        try {
            Thread.sleep(2000L);
            System.out.println("Thread4 等待2秒");
            System.out.println("Thread4 是否為守護線程 : " + Thread.currentThread().isDaemon());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }});

    // 主線程執(zhí)行完畢
    System.out.println("Main Thread Finished.");
    executorService.shutdown();
}

輸出結果2：

4.處理執(zhí)行結果

CompletableFuture還封裝了很多處理執(zhí)行結果操作。操作太多，列舉比較常用的幾種：

thenAccept()：對結果進行使用；

thenApply()：對結果進行轉(zhuǎn)換；

exceptionally()：對異常進行處理；

whenComplete()：相當于 thenAccept() + thenApply() + exceptionally().

示例：

public static void main(String[] args) {
    // thenAccept對結果進行使用
    System.out.println("------------------------------");
    CompletableFuture.supplyAsync(() -> "Thread1 Finished.").thenAccept(System.out::println);

    // thenApply對結果進行轉(zhuǎn)換
    System.out.println("------------------------------");
    CompletableFuture.supplyAsync(() -> "Thread2 Finished.")
        .thenApply(s -> s + " + thenApply()")
        .thenAccept(System.out::println);

    // exceptionally對異常進行處理
    System.out.println("------------------------------");
    CompletableFuture.supplyAsync(() -> {throw new RuntimeException("Thread3 Failed.");})
        .exceptionally(Throwable::toString).thenAccept(System.out::println);

    // 主線程執(zhí)行完畢
    System.out.println("------------------------------");
    System.out.println("Main Thread Finished.");
}

輸出結果：

whenComplete() 示例：

public static void main(String[] args) throws ExecutionException, InterruptedException {
    // thenAccept對結果進行使用
    System.out.println("------------------------------");
    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Thread1 Finished.").whenComplete(new BiConsumer<String, Throwable>() {
        @Override
        public void accept(String s, Throwable throwable) {
            System.out.println("result: " + s);
            System.out.println("throwable: " + throwable);
        }
    });

    // exceptionally對異常進行處理
    System.out.println("------------------------------");
    CompletableFuture.supplyAsync(() -> {
        throw new RuntimeException("Thread3 Failed.");
    }).whenComplete(new BiConsumer<Object, Throwable>() {
        @Override
        public void accept(Object s, Throwable throwable) {
            System.out.println("result: " + s);
            System.out.println("throwable: " + throwable);
        }
    });

    System.out.println("------------------------------");
    System.out.println("future.get(): " + future.get());

    // 主線程執(zhí)行完畢
    System.out.println("------------------------------");
    System.out.println("Main Thread Finished.");
}

輸出結果：