为什么每个Java开发者都应该掌握CompletableFuture？深入探索这一强大的并发工具！

1 如何正确处理异步任务的异常情况？

想象一下，用餐厅的例子来比喻 CompletableFuture 的异常处理机制。在一个餐厅点了一道菜。这个过程可以分成几个阶段，类似于 CompletableFuture 的异步处理。

点菜（发起异步任务）：你向服务员点了一道菜，服务员去厨房准备这道菜。这个过程是异步的，意味着你不需要一直等待，服务员会在后台完成这个任务。

处理菜品（任务完成）：有可能厨房会成功做出你点的菜（任务成功），也有可能因为某些问题（比如原料不足、厨师失误等）而做不出这道菜（任务失败）。

对于CompletableFuture 提供了多种方式来捕捉和处理异常，确保程序的健壮性和稳定性，在执行异步任务时可能会抛出异常，为了处理这些异常，可以使用 handle() 和exceptionally()方法。

CompletableFuture 在执行异步任务时可能会抛出异常。为了处理这些异常，可以使用 handle() 和 exceptionally() 方法。

handle() 方法可以捕捉并处理任务执行过程中的异常。这种方法接受两个参数：一个函数用于处理正常结果，另一个函数用于处理异常。无论异步任务成功还是失败，handle() 方法都会被调用。

想象一下，厨房有一位大厨，他会处理所有情况，无论菜品成功还是失败。

成功的情况：如果菜做好了，大厨会给你一道美味的菜，并附上一张餐后甜点的菜单作为额外的惊喜。

失败的情况：如果因为某种原因菜做不好，大厨会告诉你出了问题，并提供一道替代的菜品（比如优惠的招牌菜）来弥补。

假设有一个异步任务可能会抛出异常，使用 handle() 方法来处理这种情况：

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (Math.random() > 0.5) {
        throw new RuntimeException("Something went wrong");
    }
    return "Success";
});

// handle() 方法会处理正常结果和异常情况
CompletableFuture<String> handledFuture = future.handle((result, ex) -> {
    if (ex != null) {
        // 处理异常
        return "Error handled: " + ex.getMessage();
    }
    // 处理正常结果
    return "Result: " + result;
});

exceptionally() 方法是只处理异常，不关心正常结果。它接收一个函数，这个函数接受异常作为输入，并返回一个补偿结果。

想象一下，服务员只处理菜品做坏的情况，但对成功的情况不做任何额外处理。

成功的情况：如果菜品做好了，你就可以享受这道菜，服务员不会干预。

失败的情况：如果菜品做坏了，服务员会向你道歉，并给你一张打折券作为补偿。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (Math.random() > 0.5) {
        throw new RuntimeException("Something went wrong");
    }
    return "Success";
});

// exceptionally() 方法仅在任务失败时处理异常
CompletableFuture<String> exceptionallyFuture = future.exceptionally(ex -> {
    // 处理异常
    return "Error handled: " + ex.getMessage();
});

有时，异常处理不仅仅是为了返回一个错误消息，还可能需要进行某些恢复操作。例如，可能需要尝试执行一个备用任务。

想象一下，大厨不仅处理了失败情况，还安排了一种恢复操作，比如提供备用菜单。

成功的情况：如果菜做好了，大厨会给你一道菜，并附加一个额外的惊喜。

失败的情况：如果菜做不好，大厨会给你一个替代菜单，还会安排另一位厨师来准备这道菜，确保你不会空手而归。

结合 handle() 和 thenCompose() 来实现这个需求：

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (Math.random() > 0.5) {
        throw new RuntimeException("Something went wrong");
    }
    return "Success";
});

// handle() 捕捉到异常后，使用备用任务进行恢复
// thenCompose() 确保无论是正常结果还是恢复结果都会被正确处理
CompletableFuture<String> recoveredFuture = future.handle((result, ex) -> {
    if (ex != null) {
        // 异常时执行备用任务
        return CompletableFuture.supplyAsync(() -> "Recovered from error");
    }
    // 正常结果直接返回
    return CompletableFuture.completedFuture("Result: " + result);
}).thenCompose(identity -> identity);

2 如何设置 CompletableFuture 的超时时间？

设置 CompletableFuture 的超时时间可以确保任务在指定时间内完成，否则就会被取消。实现超时设置的常用方法是利用 completeOnTimeout 方法或者 orTimeout 方法。

completeOnTimeout 方法允许在超时后自动完成 CompletableFuture，并提供一个默认值。

有一个任务预计会在 2 秒内完成，但超时设置为 1 秒，可以这样设置：

// 任务在 1 秒内未完成，CompletableFuture 会以 "Timed out" 作为结果自动完成
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(2000); // 模拟长时间的计算
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    return "Completed";
}).completeOnTimeout("Timed out", 1, TimeUnit.SECONDS);

另一种方法是使用 orTimeout 方法，它会在超时后抛出 TimeoutException，如果在指定时间内任务没有完成，就会触发这个异常。

// 任务未在 1 秒内完成，CompletableFuture 将抛出 "TimeoutException"
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        // 模拟长时间的计算
        Thread.sleep(2000); 
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    return "Completed";
}).orTimeout(1, TimeUnit.SECONDS);

3 如何取消正在执行的CompletableFuture任务？

想象一下，有一个人正在厨房里做一道复杂的菜肴。这个过程需要时间，并且他已经在炒菜锅前站了很久。他的任务是完成这道菜，但有时候这道菜可能需要比预期更长的时间。

取消正在执行的 CompletableFuture 任务通常涉及到两个步骤，由于 CompletableFuture 本身没有直接的取消方法，取消任务的操作需要通过控制任务的执行流来实现。

一种常见的方法是利用 ExecutorService 和 Future，当使用 ExecutorService 提交任务时，可以通过 Future 对象来取消任务。

也就是说，通过让这个人离开厨房，这样他就不再继续做这道菜。这种情况就像是在厨房里放了一个计时器，设定了时间限制。当计时器响起时，他必须停止做菜。

创建一个 CompletableFuture 时，可以使用 ExecutorService 来管理任务的执行：

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(() -> {
    try {
        Thread.sleep(5000); // 模拟长时间的计算
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    return "Completed";
});

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    try {
        return future.get();
    } catch (Exception e) {
        throw new CompletionException(e);
    }
}, executor);

// future 代表了正在执行的任务
// 尝试取消任务
future.cancel(true); 

如果任务正在执行且支持中断（如调用了 Thread.sleep），它会在下次检查中被中断，为了确保在 CompletableFuture 中处理取消逻辑，可以设置一个超时来自动取消：

// orTimeout 方法会在指定时间内自动完成 CompletableFuture
// 如果任务未完成，则会超时
// 任务内部应考虑对中断的响应
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(5000); // 模拟长时间的计算
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return "Cancelled";
    }
    return "Completed";
}).orTimeout(2, TimeUnit.SECONDS);

让我们将事前的忧虑，换为事前的思考和计划吧！