CompletableFuture.supplyAsync()默认超时时间

CompletableFuture.supplyAsync()方法是Java 8中引入的一个异步编程工具，它可以在后台执行一个任务，并返回一个CompletableFuture对象，该对象可以用于获取任务的结果或处理任务的完成状态。

CompletableFuture.supplyAsync()方法没有默认的超时时间。它会一直等待任务的完成，直到任务完成或者手动取消任务。

如果你需要设置超时时间，可以使用CompletableFuture的方法之一：completeOnTimeout()。这个方法可以在指定的时间内等待任务的完成，如果超时则返回一个默认值。

下面是一个示例代码：

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 执行耗时任务
    return "Hello, world!";
});

String result = future.completeOnTimeout("Timeout", 5, TimeUnit.SECONDS)
                      .join();

在上面的代码中，我们使用completeOnTimeout()方法设置了超时时间为5秒，并指定了超时后返回的默认值为"Timeout"。如果任务在5秒内完成，将返回任务的结果；如果超过5秒仍未完成，则返回默认值"Timeout"。

相关问题

CompletableFuture.runAsync执行耗时

### 使用 `CompletableFuture.runAsync` 执行长时间运行任务的最佳实践

当使用 `CompletableFuture.runAsync` 来执行可能耗时较长的操作时，有几个最佳实践可以帮助提高程序的效率和可靠性。

#### 设置自定义线程池
默认情况下，`runAsync` 方法会使用公共的 ForkJoinPool.commonPool() 线程池来执行异步操作。然而，在处理大量或长时间运行的任务时，建议创建专用的线程池以避免阻塞其他任务：

ExecutorService customThreadPool = Executors.newFixedThreadPool(10);
CompletableFuture<Void> futureWithCustomPool =
    CompletableFuture.runAsync(() -> {
        // 长时间运行的任务代码...
    }, customThreadPool);

通过这种方式可以更好地控制并发度以及资源分配[^1]。

#### 超时机制
为了防止某些异常情况下的无限期等待，可以在调用处设置超时期限。如果超过指定的时间未完成，则抛出 TimeoutException 并取消该 Future 对象:

try {
    CompletableFuture<Void> longRunningTask = 
        CompletableFuture.runAsync(/*...*/);

    // 尝试获取结果，最多等待5秒
    Void result = longRunningTask.get(5, TimeUnit.SECONDS); 

} catch (TimeoutException e) {
    // 处理超时错误
}

这有助于及时发现潜在问题并采取相应措施[^2]。

#### 错误恢复策略
对于可能出现失败的情况，应该考虑加入重试逻辑或其他形式的容错方案。例如利用 exceptionally 或 handle 方法来进行优雅降级：

CompletableFuture<Void> resilientOperation =
    CompletableFuture.runAsync(() -> /* ... */)
                      .exceptionally(ex -> {
                          log.error("An error occurred", ex);
                          return null;
                      });

这样即使遇到不可预见的问题也能保持系统的稳定性和可用性[^3]。

#### 组合多个异步任务
如果有多个相互独立但又需要一起协调工作的子任务，那么可以通过 thenCompose、allOf 和 anyOf 这样的组合器将它们串联起来形成更复杂的流程图结构。比如下面的例子展示了如何同时发起两个请求并将最终的结果汇总在一起：

public PriceResult comparePricesConcurrently(String productId){
    
    CompletableFuture<PriceInfo> priceQuery = 
        CompletableFuture.supplyAsync(() ->
            queryExternalServiceForPrice(productId));

    CompletableFuture<PromotionDetails> promoCheck = 
        CompletableFuture.supplyAsync(() ->
            checkPromotionsApplicableToProduct(productId));
        
    return CompletableFuture.allOf(priceQuery,promoCheck).thenApply(v->
         combineResultsIntoFinalOutput(
             priceQuery.join(),promoCheck.join())
     ).join();
}

这种方法不仅提高了整体吞吐量还简化了业务逻辑之间的依赖关系管理[^4]。

java CompletableFuture.runAsync 异常没抛出

`CompletableFuture.runAsync()` 是 Java 中用于异步执行任务的方法，它将一个 Runnable 或 Callable 对象提交到线程池中执行。这个方法通常不会直接抛出异常，因为它返回的是一个 `CompletableFuture`，这个 Future 表示异步操作的结果。

当在 `runAsync()` 后发生异常时，有几种可能的情况：

1. 如果在 Runnable 或 Callable 的实现内部抛出了未捕获的异常，那么异常会默认被捕获并封装在一个 CompletionException 中。这意味着，你需要通过 `.exceptionally()` 方法或 `.get()`（带有超时或无检查异常处理）来获取并处理异常。

CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Uncaught exception");
}).exceptionally(exception -> {
    // 处理异常
    return null;
});

2. 如果你想要让异常立即中断整个异步链路，可以使用 `.handle()` 方法提供一个 ExceptionHandler 来处理异常。

CompletableFuture.runAsync(() -> {
    throw new RuntimeException("Throwing an exception");
}).handle((result, exc) -> {
    if (exc != null) {
        // 异常被捕获并处理
        log.error("An error occurred", exc);
        // 可能需要取消其他依赖的任务
        future.cancel(true);
    }
    return result;
});