Java中替代轮询检查多异步线程状态的方案咨询

我在MyClassB中定义了getProductCall()方法，该方法会被MyClassA的方法异步触发，核心代码如下：

public void getProductCall() {
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                productRequest = service.createS4ProductRequest(getRepriceItems());
                // 调用外部系统的REST接口
                String response = pricing.getS4ProductResponse(quote.getAssetQuoteNrAndVrsn(), productRequest);
                // 更新状态供MyClassA轮询检查
                setProductResponse(response);
                productPriceProcessEnded = true;
            } catch (Exception e) {
                productPriceErrorOccured = true;
                e.printStackTrace();
            }
        }
    }).start();
}

目前我在MyClassA中通过轮询方式检查异步任务是否完成：

for(int i=0;i<1000000000;i++) {
    if(!networkAsynCalls.isListPriceErrorOccured()) {
        if(networkAsynCalls.isListPriceprocessEnded()) {
            return networkAsynCalls.getListReponse();
        } else {
            Thread.sleep(250);
            continue;
        }
    } else return null;
}

现在想咨询：能否使用Java内置方法、线程池等机制替代这种低效的轮询方式？ 我的约束条件是：

• 异步线程所属的方法位于另一个类（MyClassB）
• MyClassB中还有多个类似的异步方法，需要在MyClassA中统一检查所有方法的完成状态

当然可以！Java提供了多种内置机制来替代这种低效的轮询，完全适配你提到的跨类异步任务、多任务统一检查的需求。下面是几种最实用的方案：

方案1：使用CompletableFuture（推荐，Java 8+） #

这是最贴合你场景的方案，它天生支持异步任务的编排、结果回调，还能轻松处理多任务的聚合，完全不需要手动维护状态变量。

修改MyClassB的方法 #

把原来的void方法改成返回CompletableFuture<String>，将异步逻辑直接封装进去：

public CompletableFuture<String> getProductCall() {
    return CompletableFuture.supplyAsync(() -> {
        try {
            productRequest = service.createS4ProductRequest(getRepriceItems());
            return pricing.getS4ProductResponse(quote.getAssetQuoteNrAndVrsn(), productRequest);
        } catch (Exception e) {
            // 把异常包装成CompletionException，方便上层统一处理
            throw new CompletionException(e);
        }
    });
}

如果有其他类似的异步方法（比如getAnotherProductCall()），同样改成返回CompletableFuture<String>即可。

在MyClassA中统一处理所有异步任务 #

你可以收集所有MyClassB的异步任务Future，用CompletableFuture.allOf()等待全部完成，再统一获取结果或处理异常：

public List<String> handleAllAsyncTasks(MyClassB networkAsynCalls) {
    // 收集所有需要执行的异步任务
    CompletableFuture<String> productTask = networkAsynCalls.getProductCall();
    CompletableFuture<String> anotherProductTask = networkAsynCalls.getAnotherProductCall();
    // 可按需添加更多任务...

    // 等待所有任务完成
    CompletableFuture<Void> allTasks = CompletableFuture.allOf(productTask, anotherProductTask);

    try {
        // 阻塞等待所有任务完成（也可以用thenAccept()等回调实现非阻塞处理）
        allTasks.get();
        // 逐个获取任务结果
        List<String> results = new ArrayList<>();
        results.add(productTask.get());
        results.add(anotherProductTask.get());
        return results;
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return null;
    } catch (ExecutionException e) {
        // 捕获任务执行中的异常
        Throwable cause = e.getCause();
        cause.printStackTrace();
        return null;
    }
}

这种方式完全摒弃了手动维护状态变量的繁琐，所有任务状态都由CompletableFuture内部管理，还支持灵活的非阻塞回调（比如用thenAccept()处理成功结果、exceptionally()处理异常）。

方案2：使用ExecutorService + Future（Java 5+） #

如果你的项目还在使用Java 8之前的版本，可以用ExecutorService管理线程池，通过Future对象跟踪任务状态。

步骤1：在MyClassB中定义线程池 #

避免每次创建新线程，用线程池复用资源：

// 可根据实际需求调整线程池大小
private ExecutorService executor = Executors.newFixedThreadPool(5);

public Future<String> getProductCall() {
    return executor.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
            productRequest = service.createS4ProductRequest(getRepriceItems());
            return pricing.getS4ProductResponse(quote.getAssetQuoteNrAndVrsn(), productRequest);
        }
    });
}

步骤2：在MyClassA中等待所有任务完成 #

public List<String> handleAllAsyncTasks(MyClassB networkAsynCalls) {
    List<Future<String>> futures = new ArrayList<>();
    futures.add(networkAsynCalls.getProductCall());
    futures.add(networkAsynCalls.getAnotherProductCall());

    List<String> results = new ArrayList<>();
    for (Future<String> future : futures) {
        try {
            // get()会阻塞直到任务完成，也可以用get(timeout, unit)设置超时时间
            results.add(future.get());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return null;
        } catch (ExecutionException e) {
            e.getCause().printStackTrace();
            return null;
        }
    }
    return results;
}

注意：使用完线程池后，记得调用executor.shutdown()关闭，避免资源泄漏。

方案3：使用CountDownLatch（适合简单的多任务等待场景） #

如果不需要获取每个任务的具体结果，只需要等待所有任务完成，CountDownLatch是个轻量的选择。

修改MyClassB的方法 #

需要传入CountDownLatch，任务完成时调用countDown()：

public void getProductCall(CountDownLatch latch) {
    new Thread(() -> {
        try {
            productRequest = service.createS4ProductRequest(getRepriceItems());
            String response = pricing.getS4ProductResponse(quote.getAssetQuoteNrAndVrsn(), productRequest);
            setProductResponse(response);
        } catch (Exception e) {
            productPriceErrorOccured = true;
            e.printStackTrace();
        } finally {
            // 无论成功失败，都减少计数
            latch.countDown();
        }
    }).start();
}

在MyClassA中等待所有任务完成 #

public void waitForAllTasks(MyClassB networkAsynCalls) {
    // 假设有3个异步任务，初始化计数为3
    int taskCount = 3;
    CountDownLatch latch = new CountDownLatch(taskCount);

    // 触发所有任务
    networkAsynCalls.getProductCall(latch);
    networkAsynCalls.getAnotherProductCall(latch);
    networkAsynCalls.getThirdProductCall(latch);

    try {
        // 阻塞直到所有任务调用了countDown()
        latch.await();
        // 任务全部完成后，检查状态或处理结果
        if (!networkAsynCalls.isAnyErrorOccured()) {
            // 处理成功逻辑
        } else {
            // 处理异常逻辑
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

这种方式虽然还需要维护状态变量，但不需要轮询，而是通过await()阻塞等待，比轮询高效得多。

为什么这些方案比轮询好？ #

• 效率更高：轮询会持续消耗CPU资源，而这些内置机制采用通知/唤醒模型，任务完成时主动通知等待线程，避免无效循环。
• 代码更简洁：不需要手动维护xxxEnded、xxxErrorOccured这类状态变量，减少出错概率。
• 更灵活：支持非阻塞处理、超时控制、任务编排（串行/并行执行）等高级特性。
• 可扩展性更好：新增异步任务时，只需要添加对应的Future或调整CountDownLatch的计数，无需修改核心等待逻辑。

内容的提问来源于stack exchange，提问作者arun