串行任务方法

thenRun & thenRunAsync (无返回值)

• thenRun：使用主线程或者执行上一步任务的子线程，串行执行任务。无返回值。

• thenRunAsync：串行执行任务，从公共的commonPool线程中获取一个子线程，执行任务。无返回值。

thenRun

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    System.out.println("执行异步任务");
}).thenRun(() -> {
    System.out.println("执行异步任务完成后的回调");
});

thenRunAsync

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    System.out.println("执行异步任务");
}).thenRunAsync(() -> {
    System.out.println("执行异步任务完成后的回调");
});

thenAccept & thenAcceptAsync （无返回值）

• thenAccept：使用主线程或者上一步任务的线程，串行执行任务。将上一步任务执行的结果作为当前任务方法的参数，执行指定的任务。无返回值。

• thenAcceptAsync：串行执行任务，将上一步任务执行的结果作为当前任务方法执行时候的参数，然后从公共 commonPool 线程中获取一个子线程，执行任务，无返回值。

supplyAsync

CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务");
    return "异步任务返回值";
}).thenAccept((String s) -> {
    System.out.println("执行异步任务完成后的回调");
});

supplyAsync

CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务");
    return "异步任务返回值";
}).thenAcceptAsync((String s) -> {
    System.out.println("执行异步任务完成后的回调");
});

whenComplete & whenCompleteAsync （无返回值）

• whenComplete：使用主线程或者上一步任务的线程，串行执行任务，将上一步任务执行的结果和异常作为当前任务方法的参数，执行任务。无返回值。

• whenCompleteAsync：串行执行任务，将上一步任务执行的结果或异常作为当前任务方法的参数，然后从commonPool线程池中获取一个子线程，执行任务，无返回值。

whenComplete

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务");
    return "异步任务返回值";
}).`((result, e) -> {
    System.out.println("执行异步任务完成后的回调");
    System.out.println("异步任务返回值：" + result);
});

whenCompleteAsync

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务");
    return "异步任务返回值";
}).whenCompleteAsync((result, e) -> {
    System.out.println("执行异步任务完成后的回调");
    System.out.println("异步任务返回值：" + result);
});

thenApply & thenApplyAsync

• thenApply：使用主线程或者上一步任务的线程，串行执行任务。将上一步任务的返回值作为当前任务方法的入参，执行任务，最终将执行结果返回。

• thenApplyAsync：串行执行任务，将上一步任务执行的结果作为当前任务执行时的参数，然后从公共commonPool线程池中获取一个子线程，执行任务，并返回执行结果。

thenApply

CompletableFuture<Boolean> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务");
    return "异步任务返回值";
}).thenApply((String s) -> {
    System.out.println("执行异步任务完成后的回调");
    return true;
});

thenApplyAsync

CompletableFuture<Boolean> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务");
    return "异步任务返回值";
}).thenApplyAsync((String s) -> {
    System.out.println("执行异步任务完成后的回调");
    return true;
});

handle & handleAsync

• handle：使用主线程或者执行上一步任务的线程，串行执行任务。将上一步任务的返回值和异常作为当前任务方法的参数，执行任务，并返回执行后的结果。

• handleAsync：串行执行任务，将上一步任务的返回值和异常作为当前任务方法的参数，然后从公共commonPool 线程池中获取一个子线程，执行任务，并返回执行后的结果。

handle

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务");
    return "异步任务返回值";
}).handle((result, throwable) -> {
    if (throwable != null) {
        System.out.println("异步任务执行过程中出现异常：" + throwable.getMessage());
        return "hello world";
    }
    return result;
});

handleAsync

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务");
    return "异步任务返回值";
}).handleAsync((result, throwable) -> {
    if (throwable != null) {
        System.out.println("异步任务执行过程中出现异常：" + throwable.getMessage());
        return "hello world";
    }
    return result;
});

thenCompose & thenComposeAsync （返回新任务）

• thenCompose：使用主线程或者上一步任务的线程，串行执行任务，按照顺序组合两个有依赖关系的任务，将上一步任务的返回值作为当前任务方法的参数，执行任务，并返回一个新任务。

• thenComposeAsync：串行执行任务，按照顺序组合两个有依赖关系的任务，将上一步任务的返回值作为当前任务方法的参数，然后从公共的commonPool线程池中获取一个子线程，执行任务，并返回一个新任务。

thenComposeAsync

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务");
    return 1;
}).thenComposeAsync((result) -> {
    System.out.println("执行异步任务完成后的回调");
    return CompletableFuture.supplyAsync(() -> result+1);
}).thenComposeAsync((result) -> {
    System.out.println("执行异步任务完成后的回调");
    return CompletableFuture.supplyAsync(() -> {
        return result + 1;
    });
});

Integer result = future.join();
System.out.println("计算结果:" + result); // 3

thenComposeAsync

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务");
    return "异步任务返回值";
}).thenComposeAsync((result) -> {
    System.out.println("执行异步任务完成后的回调");
    return CompletableFuture.supplyAsync(() -> {
        return result + "组合任务";
    });
});