Java8 CompletableFuture 异步执行操作

Java8引入了CompletableFuture类，它是对之前的Future和Promise模式的完美实现。CompletableFuture不仅能同步获取异步执行结果，还能设置执行完成后的回调函数和流式调用。下面是“Java8 CompletableFuture 异步执行操作”的完整攻略。

创建CompletableFuture对象

要创建CompletableFuture对象，可以使用静态工厂方法：

CompletableFuture<T> completableFuture = new CompletableFuture<>();

// 指定Executor
CompletableFuture<T> completableFuture = new CompletableFuture<>(executor);

异步运行任务

CompletableFuture的核心方法是supplyAsync()，这个方法会异步启动一个任务，并返回一个CompletableFuture对象。

CompletableFuture.supplyAsync(() -> {
    // 长时间的计算任务
    return result;
});

完成事件

我们可以监听异步任务完成的事件，然后执行相应的处理操作。thenApply()方法会在CompletableFuture执行完毕后返回一个新的CompletableFuture对象，用于处理运行的结果。

CompletableFuture.supplyAsync(() -> {
    // 长时间的计算任务
    return result;
}).thenApply(r -> {
    String result = r + "- extra text";
    return result;
});

这里的thenApply()方法会接受异步任务的结果，之后就会添加一些额外的文本。

组合任务

我们可以使用thenCompose()组合多个异步任务，并返回一个新的CompletableFuture对象。thenCompose()方法会等待前面的任务完成，并使用前面任务的结果执行后面的任务。

CompletableFuture.supplyAsync(() -> {
    // 长时间的计算任务
    return result;
}).thenCompose(previousResult -> CompletableFuture.supplyAsync(() -> {
    // 使用前面的结果执行任务
    return newResult;
}));

这里的thenCompose()方法会接受来自于前面CompletableFuture执行的结果，并使用这个结果执行后面的异步任务。

异常处理

在CompletableFuture中，可以使用exceptionally()方法给异步执行出现异常时提供程序的默认行为。它会在抛出异常的情况下返回一个默认值。

CompletableFuture.supplyAsync(() -> {
    // 一些可能抛出异常的计算
}).exceptionally(e -> {
    // 降级操作
    return "降级结果";
});

参考示例

示例1：

下面的示例使用CompletableFuture异步执行多个任务，并返回执行结果：

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    try {
        // 长时间任务的执行
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "Hello";
});

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    try {
        // 长时间任务的执行
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return " world!";
});

CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
    try {
        // 长时间任务的执行
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "Hi, there.";
});

CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2, future3);

CompletableFuture<List<String>> combinedFuture = allFutures.thenApply(v -> {
    List<String> result = new ArrayList<>();
    result.add(future1.join());
    result.add(future2.join());
    result.add(future3.join());
    return result;
});

combinedFuture.thenAcceptAsync(System.out::println);

示例2：

下面的示例使用CompletableFuture异步执行任务，当任务执行完成后，返回一个带字符串前缀的结果：

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    try {
        // 长时间任务的执行
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "World";
});

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    try {
        // 长时间任务的执行
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "Hello ";
});

CompletableFuture<String> resultFuture = future1.thenCombine(future2, (result1, result2) -> result2 + result1);

String result = resultFuture.get();
System.out.println(result);

在这里，我们使用了thenCombine()方法来使两个异步任务返回的结果组合。结果为"Hello World"。