并行任务方法

thenCombine & thenCombineAsync

• thenCombine：并行执行任务，从 commonPool 线程池中获取线程，并行执行两个任务，等到两个任务都执行结束后，执行一个新的任务方法，将之前两个任务的执行【结果】作为新任务方法的【参数】，然后返回并执行新任务。新任务执行结束后，将返回指定类型结果。

• thenCombineAsync：并行执行任务，从 commonPool 线程池中获取线程，并行执行两个任务，等到两个任务都执行结束后，继续从 commonPool 线程池中获取一个子线程，执行一个新的任务方法，将之前两个任务的执行【结果】作为新任务方法的【参数】，然后返回并执行新任务。新任务执行结束后，将返回指定类型结果。

如果上一个阶段执为异常完成，则不会执行组合的下一个阶段，直接抛出异常信息。

thenCombine

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务1");
    return "执行异步任务1";
}).thenCombine(CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务2");
    return "执行异步任务2";
}), (result1, result2) -> {
    System.out.println("执行异步任务1和异步任务2完成后的回调");
    return result1 + result2;
});

Second Tab

thenAcceptBoth & thenAcceptBothAsync

• thenAcceptBoth：并行执行任务，从公共的 commonPool 线程池中获取线程，并行执行两个任务，等到两个任务都执行结束后，执行一个新的任务方法，将之前两个任务的执行【结果】作为新任务方法的【参数】，然后返回并执行新任务。新任务执行结束后，没有返回值。

• thenAcceptBothAsync：并行执行任务，从公共的 commonPool 线程池中获取线程，并行执行两个任务，等到两个任务都执行结束后，继续从 commonPool 线程池中获取一个子线程，执行一个新的任务方法，将之前两个任务的执行【结果】作为新任务方法的【参数】，然后返回并执行新任务。新任务执行结束后，没有返回值。

thenAcceptBoth

CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务1");
    return "执行异步任务1";
}).thenAcceptBoth(CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务2");
    return "执行异步任务2";
}), (result1, result2) -> {
    System.out.println("执行异步任务1和异步任务2完成后的回调");
});

thenAcceptBothAsync

runAfterBoth和runAfterBothAsync

• runAfterBoth：并行执行任务，从公共的 commonPool 线程池中获取线程，并行执行两个任务，等到两个任务都执行结束后，执行一个新的任务方法，没有返回值。

• runAfterBothAsync：并行执行任务，从公共的 commonPool 线程池中获取线程，并行执行两个任务，等到两个任务都执行结束后，继续从 commonPool 线程池中获取一个子线程，执行一个新的任务方法，没有返回值。

runAfterBoth

CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务1");
    return "执行异步任务1";
}).runAfterBoth(CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务2");
    return "执行异步任务2";
}), () -> {
    System.out.println("执行异步任务1和异步任务2完成后的回调");
});

runAfterBothAsync

applyToEither和applyToEitherAsync

• applyToEither：并行执行任务，从公共的 commonPool 线程池中获取线程，并行执行两个任务，等到其中一个任务执行结束后，执行一个新的任务方法，将第一个执行结束的任务的执行【结果】作为新任务方法的【参数】，然后返回并执行新任务。新任务执行结束后，将返回指定类型结果。

• applyToEitherAsync：并行执行任务，从公共的 commonPool 线程池中获取线程，并行执行两个任务，等到其中一个任务执行结束后，继续从 commonPool 线程池中获取一个子线程，执行一个新的任务方法，将第一个执行结束的任务的执行【结果】作为新任务方法的【参数】，然后返回并执行新任务。新任务执行结束后，将返回指定类型结果。

applyToEither

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务1");
    return "执行异步任务1";
}).applyToEither(CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务2");
    return "执行异步任务2";
}), result -> {
    System.out.println("执行异步任务1和异步任务2中的一个完成后的回调");
    return result;
});

applyToEitherAsync

runAfterEither和runAfterEitherAsync

• runAfterEither：并行执行任务，从公共的 commonPool 线程池中获取线程，并行执行两个任务，等到其中一个任务执行结束后，执行一个新的任务方法，没有返回值。

• runAfterEitherAsync：并行执行任务，从公共的 commonPool 线程池中获取线程，并行执行两个任务，等到其中一个任务执行结束后，继续从 commonPool 线程池中获取一个子线程，执行一个新的任务方法，没有返回值。

runAfterEither

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    System.out.println("执行异步任务1");
}).runAfterEither(CompletableFuture.runAsync(() -> {
    System.out.println("执行异步任务2");
}), () -> {
    System.out.println("执行异步任务1和异步任务2中的一个完成后的回调");
});

runAfterEitherAsync

acceptEither和acceptEitherAsync

• acceptEither：并行执行任务，从公共的 commonPool 线程池中获取线程，并行执行两个任务，等到其中一个任务执行结束后，执行一个新的任务方法，将第一个执行结束的任务的执行【结果】作为新任务方法的【参数】，然后返回并执行新任务。新任务执行结束后，没有返回值。

• acceptEitherAsync：并行执行任务，从公共的 commonPool 线程池中获取线程，并行执行两个任务，等到其中一个任务执行结束后，继续从 commonPool 线程池中获取一个子线程，执行一个新的任务方法，将第一个执行结束的任务的执行【结果】作为新任务方法的【参数】，然后返回并执行新任务。新任务执行结束后，没有返回值。

acceptEither

CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务1");
    return "执行异步任务1";
}).acceptEither(CompletableFuture.supplyAsync(() -> {
    System.out.println("执行异步任务2");
    return "执行异步任务2";
}), result -> {
    System.out.println("执行异步任务1和异步任务2中的一个完成后的回调");
});

acceptEitherAsync

allOf

• allOf：并行执行任务，从公共的 commonPool 线程池中获取线程，并行执行多个任务，等待所有任务都执行结束，没有返回值。

CompletableFuture<Void> future = CompletableFuture.allOf(
        CompletableFuture.supplyAsync(() -> {
            System.out.println("执行异步任务1");
            return "执行异步任务1";
        }),
        CompletableFuture.supplyAsync(() -> {
            System.out.println("执行异步任务2");
            return "执行异步任务2";
        }),
        CompletableFuture.supplyAsync(() -> {
            System.out.println("执行异步任务3");
            return "执行异步任务3";
        })
);

anyOf

• anyOf：并行执行任务，从公共的 commonPool 线程池中获取线程，并行执行多个任务，等到其中任意一个任务执行结束后，返回第一个先执行完成任务的返回值。

CompletableFuture<Object> future = CompletableFuture.anyOf(
        CompletableFuture.supplyAsync(() -> {
            System.out.println("执行异步任务1");
            return "执行异步任务1";
        }),
        CompletableFuture.supplyAsync(() -> {
            System.out.println("执行异步任务2");
            return "执行异步任务2";
        }),
        CompletableFuture.supplyAsync(() -> {
            System.out.println("执行异步任务3");
            return "执行异步任务3";
        })
);