Java中的CountDownLatch多方面深入解析

public class ServiceBootstrap {
    private static final int SERVICE_COUNT = 3;
    private static CountDownLatch latch = new CountDownLatch(SERVICE_COUNT);
 
    public static void main(String[] args) {
        // 启动依赖服务
        startService("Database", 2000);
        startService("Redis", 1500);
        startService("MQ", 1000);
 
        try {
            latch.await(); // 阻塞主线程，等待所有服务就绪
            System.out.println("所有服务启动完成，主服务开始运行！");
        } catch (InterruptedException e) { /* ... */ }
    }
 
    private static void startService(String name, long delay) {
        new Thread(() -> {
            try {
                Thread.sleep(delay); // 模拟服务初始化
                System.out.println(name + " 服务就绪");
            } catch (Exception e) { /* ... */ } finally {
                latch.countDown(); // 服务就绪后减计数
            }
        }).start();
    }
}

Redis 服务就绪  
MQ 服务就绪  
Database 服务就绪  
所有服务启动完成，主服务开始运行！
```[4,7](@ref)  
 
---
 
#### 🛒 **场景 2：电商详情页数据聚合**  
**问题**：商品详情页需并行调用交易服务（价格）、库存服务（库存）、推荐服务（相关商品），全部返回后才能渲染页面。  
**解决方案**：  
```java
public class ProductDetailService {
    private CountDownLatch latch = new CountDownLatch(3);
    private PriceResult priceResult;
    private StockResult stockResult;
    private RecommendResult recommendResult;
 
    public void loadDetail() throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        executor.submit(() -> {
            priceResult = fetchPrice(); // 调用价格服务
            latch.countDown();
        });
        executor.submit(() -> {
            stockResult = fetchStock(); // 调用库存服务
            latch.countDown();
        });
        executor.submit(() -> {
            recommendResult = fetchRecommends(); // 调用推荐服务
            latch.countDown();
        });
 
        latch.await(500, TimeUnit.MILLISECONDS); // 超时 500ms 避免页面卡死
        renderPage(priceResult, stockResult, recommendResult);
    }
}

public class LogAnalyzer {
    private static final int TASK_COUNT = 100;
    private CountDownLatch latch = new CountDownLatch(TASK_COUNT);
    private ResultAggregator aggregator = new ResultAggregator();
 
    public void analyze() {
        for (int i = 0; i < TASK_COUNT; i++) {
            Thread task = new Thread(() -> {
                TaskResult result = processSubTask(); // 处理子任务
                aggregator.collect(result);
                latch.countDown();
            });
            task.start();
        }
 
        latch.await(); // 阻塞主线程直至所有任务完成
        aggregator.summarize(); // 生成最终报告
    }
}