并行任务方法

thenCombine & thenCombineAsync

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

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

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;
});

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

thenAcceptBoth & thenAcceptBothAsync

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

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完成后的回调");
});

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

runAfterBoth和runAfterBothAsync

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

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完成后的回调");
});

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

applyToEither和applyToEitherAsync

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

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;
});

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

runAfterEither和runAfterEitherAsync

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

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

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

acceptEither和acceptEitherAsync

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

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中的一个完成后的回调");
});

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

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";
        })
);

最后更新于9个月前

这有帮助吗？