CountDownLatch：Java多线程的“发令枪“，一枪响千军动

CountDownLatch是什么？—— 多线程的起跑线

想象一场田径比赛：

• 所有运动员（线程）在起跑线就位
• 裁判（主线程）倒数：“3-2-1”（countDown）
• 当倒数到0时（await返回），所有运动员同时起跑

Java中的CountDownLatch就是这样一个让线程等待其他线程完成的同步工具，像极了比赛时的发令枪！

CountDownLatch的三大核心特性

1. 一次性使用（不可重置）

// 创建倒数计数器（初始值3）
CountDownLatch latch = new CountDownLatch(3);

// 工作线程完成任务后调用
void finishTask() {
    latch.countDown(); // 计数器减1
}

// 主线程等待所有任务完成
latch.await(); // 阻塞直到计数器归零

2. 主从协作模式

• 主线程：调用await()等待
• 工作线程：完成任务后调用countDown()

3. 灵活的任务完成检测

// 带超时的等待（避免无限阻塞）
boolean allDone = latch.await(1, TimeUnit.SECONDS);
if (!allDone) {
    System.out.println("有些任务超时未完成");
}

5个真实应用场景

1. 服务启动依赖检查

// 确保所有微服务就绪后再启动主服务
CountDownLatch dependencyLatch = new CountDownLatch(3);

// 检查各个依赖服务
checkDB(dependencyLatch);
checkCache(dependencyLatch);
checkMQ(dependencyLatch);

dependencyLatch.await();
startMainService();

2. 并行任务结果汇总

// 3个子任务并行执行，全部完成后汇总
CountDownLatch taskLatch = new CountDownLatch(3);

executor.execute(() -> { task1(); taskLatch.countDown(); });
executor.execute(() -> { task2(); taskLatch.countDown(); });
executor.execute(() -> { task3(); taskLatch.countDown(); });

taskLatch.await();
mergeResults();

3. 模拟高并发场景

// 1000个线程同时触发请求
CountDownLatch startLatch = new CountDownLatch(1);
CountDownLatch endLatch = new CountDownLatch(1000);

for (int i = 0; i < 1000; i++) {
    new Thread(() -> {
        startLatch.await(); // 等待发令枪
        sendRequest();
        endLatch.countDown();
    }).start();
}

startLatch.countDown(); // 开枪！
endLatch.await(); // 等待所有请求完成
generateReport();

4. 游戏关卡加载

// 加载所有资源后才能开始游戏
CountDownLatch resourceLatch = new CountDownLatch(4);

loadImages(resourceLatch);
loadSounds(resourceLatch);
loadMaps(resourceLatch);
loadScripts(resourceLatch);

showProgressBar();
resourceLatch.await();
startGame();

5. 分布式系统协调

// 等待3个节点全部响应
CountDownLatch nodeLatch = new CountDownLatch(3);

nodes.forEach(node -> 
    node.sendRequest(() -> nodeLatch.countDown())
);

if (nodeLatch.await(5, TimeUnit.SECONDS)) {
    processResponses();
} else {
    handleTimeout();
}

内部原理揭秘

// 简化版实现原理
class MyCountDownLatch {
    private int count;
    private final Object lock = new Object();
    
    MyCountDownLatch(int count) {
        this.count = count;
    }
    
    void countDown() {
        synchronized(lock) {
            if (count > 0 && --count == 0) {
                lock.notifyAll(); // 唤醒所有等待线程
            }
        }
    }
    
    void await() throws InterruptedException {
        synchronized(lock) {
            while (count > 0) {
                lock.wait(); // 计数器>0时等待
            }
        }
    }
}

常见问题解答

Q：CountDownLatch能重复使用吗？
A：不能！它是一次性的，如果需要循环使用请选择CyclicBarrier

Q：await()会阻塞工作线程吗？
A：不会！await()通常由主线程调用，工作线程只调用countDown()

Q：计数可以为0吗？
A：可以！如果创建时count=0，await()会立即返回

高级技巧

1. 组合多个Latch

// 阶段1和阶段2都完成后继续
CountDownLatch phase1 = new CountDownLatch(2);
CountDownLatch phase2 = new CountDownLatch(3);

phase1.await();
phase2.await();
startNextPhase();

2. 异常处理模式

try {
    if (!latch.await(5, TimeUnit.SECONDS)) {
        throw new TimeoutException("任务执行超时");
    }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    throw new RuntimeException("被中断", e);
}

3. 动态任务追踪

// 不确定任务数量时配合AtomicInteger
AtomicInteger remainingTasks = new AtomicInteger(N);
CountDownLatch latch = new CountDownLatch(N);

// 每完成一个任务
remainingTasks.decrementAndGet();
latch.countDown();

// 可以实时查看剩余任务数
int remaining = remainingTasks.get();

性能优化建议

1. 避免在高频代码中使用：
   CountDownLatch的await()/countDown()有同步开销

2. 合理设置初始计数：
   不要设置过大数值（建议<1000）

3. 优先使用带超时的await：
   防止系统死锁

4. 考虑Phaser替代方案：
   需要更复杂阶段控制时

一句话总结

CountDownLatch就像编程世界的"火箭发射控制器"——通过简单的倒计时机制，让主线程精确掌控多个子线程的执行节奏，是多线程协作不可或缺的同步神器！ 🚀🔢