MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

如何在Java中处理CompletableFuture的异常

2024-11-127.7k 阅读

CompletableFuture简介

在Java 8引入CompletableFuture后，异步编程变得更加简洁和高效。CompletableFuture实现了Future和CompletionStage接口，它不仅能表示一个异步操作的结果，还允许通过链式调用对异步操作进行组合和处理。例如，我们可以轻松地将多个异步任务串联、并行执行，并在任务完成时执行相应的回调。

异常处理的重要性

在异步编程中，异常处理尤为关键。由于异步任务在后台线程执行，传统的try - catch块无法直接捕获这些任务中抛出的异常。如果不妥善处理，这些未捕获的异常可能导致程序崩溃、资源泄漏或产生难以调试的错误。通过正确处理CompletableFuture中的异常，我们可以增强程序的健壮性和稳定性。

常见的异常类型

  1. 运行时异常（RuntimeException）：这是最常见的异常类型，如NullPointerException、IllegalArgumentException等。这些异常通常是由于编程错误或不正确的输入引起的。例如：
CompletableFuture.supplyAsync(() -> {
    String str = null;
    return str.length(); // 抛出NullPointerException
});
  1. 可检查异常（Checked Exception）：像IOException、SQLException等，这类异常在编译时需要显式处理。然而，CompletableFuture的方法默认不支持直接抛出可检查异常。如果要处理可检查异常，通常需要将其包装在RuntimeException中。例如：
CompletableFuture.supplyAsync(() -> {
    try {
        // 模拟文件读取操作
        java.io.FileReader reader = new java.io.FileReader("nonexistentfile.txt");
        return reader.read();
    } catch (java.io.FileNotFoundException e) {
        throw new RuntimeException(e);
    } catch (java.io.IOException e) {
        throw new RuntimeException(e);
    }
});

使用exceptionally方法处理异常

  1. 基本用法：exceptionally方法用于在CompletableFuture出现异常时提供一个替代的结果。它接收一个Function作为参数，该Function的输入是异常对象，返回值是替代结果。
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    int result = 10 / 0; // 抛出ArithmeticException
    return result;
}).exceptionally(ex -> {
    System.out.println("捕获到异常: " + ex.getMessage());
    return -1; // 替代结果
});

future.join();

在上述代码中，supplyAsync方法中的除法操作会抛出ArithmeticException异常。exceptionally方法捕获到该异常后，打印异常信息并返回 -1作为替代结果。

  1. 链式调用：exceptionally方法可以与其他CompletableFuture方法链式调用，以实现更复杂的异步操作流程。
CompletableFuture.supplyAsync(() -> "Hello")
               .thenApply(String::length)
               .thenApply(len -> len / 0) // 抛出ArithmeticException
               .exceptionally(ex -> {
                    System.out.println("捕获到异常: " + ex.getMessage());
                    return -1;
                })
               .thenAccept(System.out::println);

这里，supplyAsync提供一个字符串，thenApply方法计算字符串长度，接着另一个thenApply尝试将长度除以0从而抛出异常。exceptionally捕获异常并返回 -1，最后thenAccept打印结果。

使用whenComplete方法处理异常

  1. 基本用法：whenComplete方法在CompletableFuture完成（无论是正常完成还是因异常完成）时执行给定的操作。它接收一个BiConsumer，第一个参数是CompletableFuture的结果（如果有），第二个参数是异常（如果有）。
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    int result = 10 / 0; // 抛出ArithmeticException
    return result;
});

future.whenComplete((result, ex) -> {
    if (ex != null) {
        System.out.println("捕获到异常: " + ex.getMessage());
    } else {
        System.out.println("结果: " + result);
    }
});

try {
    future.join();
} catch (Exception e) {
    e.printStackTrace();
}

在这段代码中，whenComplete捕获到异常并打印异常信息。需要注意的是，whenComplete本身不会处理异常以防止CompletableFuture进入异常状态，因此需要额外的处理（如这里的try - catch块）来避免异常传播。

  1. 与exceptionally结合使用：whenComplete和exceptionally可以结合使用，以实现更灵活的异常处理逻辑。
CompletableFuture.supplyAsync(() -> {
    int result = 10 / 0; // 抛出ArithmeticException
    return result;
})
.whenComplete((result, ex) -> {
    if (ex != null) {
        System.out.println("whenComplete捕获到异常: " + ex.getMessage());
    }
})
.exceptionally(ex -> {
    System.out.println("exceptionally捕获到异常: " + ex.getMessage());
    return -1;
})
.thenAccept(System.out::println);

这里，whenComplete首先捕获并打印异常，然后exceptionally处理异常并返回替代结果。

使用handle方法处理异常

  1. 基本用法：handle方法在CompletableFuture完成（正常或异常）时执行给定的操作，并返回一个新的CompletableFuture。它接收一个BiFunction，第一个参数是CompletableFuture的结果（如果有），第二个参数是异常（如果有），返回值是新CompletableFuture的结果。
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    int result = 10 / 0; // 抛出ArithmeticException
    return result;
}).handle((result, ex) -> {
    if (ex != null) {
        System.out.println("捕获到异常: " + ex.getMessage());
        return -1;
    }
    return result;
});

future.join();

在上述代码中，handle方法捕获异常并返回 -1。与exceptionally不同，handle方法无论CompletableFuture是正常完成还是异常完成都会执行。

  1. 链式调用：handle方法可以与其他CompletableFuture方法链式调用，构建复杂的异步处理流程。
CompletableFuture.supplyAsync(() -> "Hello")
               .thenApply(String::length)
               .handle((len, ex) -> {
                    if (ex != null) {
                        System.out.println("捕获到异常: " + ex.getMessage());
                        return -1;
                    }
                    return len;
                })
               .thenApply(len -> len * 2)
               .thenAccept(System.out::println);

这里，supplyAsync提供字符串，thenApply计算字符串长度，handle处理可能的异常并返回长度或 -1，接着另一个thenApply将长度翻倍，最后thenAccept打印结果。

处理多个CompletableFuture的异常

  1. 使用allOf方法：CompletableFuture.allOf方法用于等待所有给定的CompletableFuture完成。如果其中任何一个CompletableFuture出现异常，整个allOf操作都会以异常结束。
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);
CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("模拟异常");
});

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

allFutures.join(); // 这里会抛出异常

try {
    allFutures.get();
} catch (InterruptedException | ExecutionException e) {
    System.out.println("捕获到异常: " + e.getMessage());
}

在上述代码中，future3抛出异常，导致allOf操作异常结束。通过try - catch块捕获异常并处理。

  1. 使用anyOf方法：CompletableFuture.anyOf方法等待任何一个给定的CompletableFuture完成。如果第一个完成的CompletableFuture抛出异常，anyOf操作也会以异常结束。
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 10;
});
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("模拟异常");
});
CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 20;
});

CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(future1, future2, future3);

try {
    Object result = anyFuture.get();
    System.out.println("结果: " + result);
} catch (InterruptedException | ExecutionException e) {
    System.out.println("捕获到异常: " + e.getMessage());
}

这里，future2首先完成并抛出异常，anyOf操作以异常结束，通过try - catch块捕获并处理异常。

自定义异常处理策略

  1. 创建自定义异常处理器：我们可以创建一个自定义的异常处理类来处理CompletableFuture中的异常，从而实现统一的异常处理逻辑。
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CustomExceptionHandler {
    public static <U> CompletableFuture<U> handleException(CompletableFuture<U> future) {
        return future.exceptionally(ex -> {
            System.out.println("自定义异常处理: " + ex.getMessage());
            // 可以根据异常类型进行不同的处理
            if (ex instanceof ArithmeticException) {
                return null;
            }
            return null;
        });
    }

    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            int result = 10 / 0; // 抛出ArithmeticException
            return result;
        });

        CompletableFuture<Integer> handledFuture = handleException(future);

        try {
            Integer result = handledFuture.get();
            System.out.println("结果: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，handleException方法接收一个CompletableFuture，并使用exceptionally方法处理异常。通过这种方式，我们可以在整个应用程序中复用这个异常处理逻辑。

  1. 全局异常处理：在企业级应用中，通常需要一个全局的异常处理机制来处理所有CompletableFuture的异常。可以通过创建一个全局的异常处理类，并在应用程序启动时进行配置。
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class GlobalExceptionHandler {
    private static final ExecutorService executor = Executors.newFixedThreadPool(10);

    public static <U> CompletableFuture<U> handleException(CompletableFuture<U> future) {
        return future.exceptionally(ex -> {
            System.out.println("全局异常处理: " + ex.getMessage());
            // 记录异常日志、通知管理员等操作
            return null;
        });
    }

    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            int result = 10 / 0; // 抛出ArithmeticException
            return result;
        }, executor);

        CompletableFuture<Integer> handledFuture1 = handleException(future1);

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            String str = null;
            return str.length(); // 抛出NullPointerException
        }, executor);

        CompletableFuture<Integer> handledFuture2 = handleException(future2);

        try {
            Integer result1 = handledFuture1.get();
            Integer result2 = handledFuture2.get();
            System.out.println("结果1: " + result1);
            System.out.println("结果2: " + result2);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

这里，handleException方法作为全局异常处理逻辑，对所有CompletableFuture进行异常处理。同时，使用ExecutorService来管理异步任务的执行。

异常处理与线程池

  1. 线程池的选择：在使用CompletableFuture时，选择合适的线程池至关重要。不同的线程池策略（如固定大小线程池、缓存线程池等）会影响异步任务的执行和异常处理。例如，使用固定大小线程池可以避免线程过多导致的资源耗尽问题。
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    private static final ExecutorService executor = Executors.newFixedThreadPool(5);

    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            int result = 10 / 0; // 抛出ArithmeticException
            return result;
        }, executor);

        try {
            Integer result = future.get();
            System.out.println("结果: " + result);
        } catch (InterruptedException | ExecutionException e) {
            System.out.println("捕获到异常: " + e.getMessage());
        } finally {
            executor.shutdown();
        }
    }
}

在上述代码中，使用newFixedThreadPool(5)创建一个固定大小为5的线程池。supplyAsync方法在这个线程池中执行异步任务。

  1. 线程池中的异常传播：当异步任务在自定义线程池中执行并抛出异常时，异常的传播和处理方式需要特别注意。默认情况下，线程池不会直接将异常传递给调用者，需要通过CompletableFuture的异常处理机制来捕获。
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExceptionPropagation {
    private static final ExecutorService executor = Executors.newSingleThreadExecutor();

    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            throw new RuntimeException("线程池中的异常");
        }, executor);

        try {
            future.get();
        } catch (InterruptedException | ExecutionException e) {
            System.out.println("捕获到异常: " + e.getCause().getMessage());
        } finally {
            executor.shutdown();
        }
    }
}

这里，runAsync方法在单线程线程池中执行任务并抛出异常。通过try - catch块捕获ExecutionException，并获取实际的异常原因进行处理。

总结与最佳实践

  1. 明确异常处理策略：在编写异步代码时，首先要明确异常处理策略。根据业务需求选择合适的异常处理方法，如exceptionally、whenComplete或handle。如果需要统一处理异常，可以创建自定义异常处理器或全局异常处理机制。

  2. 避免异常丢失：在异步操作中，要确保异常不会丢失。通过合理使用try - catch块、exceptionally等方法捕获并处理异常，防止未处理的异常导致程序崩溃。

  3. 结合线程池使用：选择合适的线程池，并了解线程池中的异常传播机制。确保异步任务在合适的线程环境中执行，同时能够正确处理线程池中抛出的异常。

  4. 日志记录：在异常处理过程中，记录详细的日志信息对于调试和排查问题非常重要。通过日志记录异常的类型、堆栈跟踪等信息，能够快速定位问题。

通过掌握以上异常处理方法和最佳实践，开发人员可以编写出更加健壮和可靠的Java异步应用程序。在实际项目中，根据具体的业务场景和需求，灵活运用这些技术，提升应用程序的稳定性和性能。