CountDownLatch——高并发场景的并发控制器

🚀 CountDownLatch——高并发场景的并发控制器 🔐

🌟 核心特性速览

🛠️ 核心方法详解

🔧 基础三件套

// 🏗️ 初始化计数器（子弹上膛）
CountDownLatch latch = new CountDownLatch(5); 

// 🚦 等待门闩开启（交通管制）
latch.await(); 

// 🔫 发射倒计时（扣动扳机）
latch.countDown();

示例

package top.miqiu.lakesword_backend.util;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class HighConcurrencySeckillDemo {
    // 商品库存（线程安全）
    private static final AtomicInteger STOCK = new AtomicInteger(1000);
    // 成功抢购计数器
    private static final AtomicInteger SUCCESS_COUNT = new AtomicInteger(0);
    // 失败计数器
    private static final AtomicInteger FAILURE_COUNT = new AtomicInteger(0);
    
    public static void main(String[] args) throws Exception {
        // 模拟5000个并发请求
        final int threadCount = 5000;
        // 创建倒计时门闩（主线程等待所有请求完成）
        CountDownLatch endLatch = new CountDownLatch(threadCount);
        // 创建线程池（根据CPU核心数优化）
        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);

        System.out.println("🔥 秒杀活动开始，库存：" + STOCK.get());
        long startTime = System.currentTimeMillis();

        // 提交所有秒杀请求
        for (int i = 0; i < threadCount; i++) {
            executor.execute(() -> {
                try {
                    // 模拟网络延迟（0~50ms随机）
                    Thread.sleep(ThreadLocalRandom.current().nextInt(50));
                    // 扣减库存（原子操作）
                    int remain = STOCK.decrementAndGet();
                    if (remain >= 0) {
                        SUCCESS_COUNT.incrementAndGet();
                    } else {
                        FAILURE_COUNT.incrementAndGet();
                        STOCK.incrementAndGet(); // 回滚超卖
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    endLatch.countDown();
                }
            });
        }

        // 等待所有请求完成（最多等待5秒）
        if (!endLatch.await(5, TimeUnit.SECONDS)) {
            System.err.println("⚠️ 警告：部分请求未在时限内完成");
        }

        // 关闭线程池
        executor.shutdown();
        
        // 统计结果
        System.out.println("\n======== 秒杀结束 ========");
        System.out.println("总耗时：" + (System.currentTimeMillis() - startTime) + "ms");
        System.out.println("成功用户：" + SUCCESS_COUNT.get());
        System.out.println("失败用户：" + FAILURE_COUNT.get());
        System.out.println("剩余库存：" + STOCK.get());
    }
}

效果

⏱️ 高级方法

// 🕒 带超时等待（安全阀）
if (!latch.await(3, TimeUnit.SECONDS)) {
    throw new TimeoutException("⌛ 等待超时！");
}

// 📊 实时监控（仪表盘）
int remaining = (int) latch.getCount();

⚙️ 底层原理揭秘

🧠 AQS架构图

🔥 关键源码片段

// 🔍 Sync内部类（核心引擎）
private static final class Sync extends AbstractQueuedSynchronizer {
    Sync(int count) { setState(count); }  // 🏭 初始化燃料
    
    protected int tryAcquireShared(int acquires) {
        return (getState() == 0) ? 1 : -1;  // 🎯 终点检测
    }
    
    protected boolean tryReleaseShared(int releases) {
        // 🔁 CAS原子操作（精密齿轮）
        for (;;) {
            int c = getState();
            if (c == 0) return false;
            int nextc = c-1;
            if (compareAndSetState(c, nextc))
                return nextc == 0;
        }
    }
}

🚨 避坑指南

⚠️ 典型问题排查表

🏆 性能优化大赛

🥇 冠军方案（Atomic版）

// 🚄 原子操作+线程池（闪电战）
ExecutorService pool = Executors.newWorkStealingPool();
AtomicInteger counter = new AtomicInteger(10_0000);
CountDownLatch latch = new CountDownLatch(10_0000);

IntStream.range(0, 10_0000).forEach(i -> 
    pool.execute(() -> {
        try {
            // 🧮 原子递减
            if(counter.decrementAndGet() >= 0) {
                // ✅ 业务逻辑
            }
        } finally {
            latch.countDown();
        }
    })
);

🏅 挑战方案（分布式版）

// 🌐 Redis分布式锁（跨节点协调）
String latchKey = "global_latch";
RedisAtomicLong counter = new RedisAtomicLong(latchKey, redisTemplate.getConnectionFactory());

// 集群节点初始化
counter.set(1000); 

// 业务线程
if (counter.decrementAndGet() >= 0) {
    // ✅ 执行业务
} else {
    // ❌ 快速失败
}

🧪 压力测试报告

📊 性能对比（单机环境）

📈 优化建议

1. 预热线程池 🔥：提前创建核心线程
2. 批量countDown 💥：合并多次触发
3. 层级门闩 🎚️：多阶段任务拆分

🚀 扩展阅读推荐

1. AQS深度解析 🔍
2. Disruptor无锁框架 💫
3. 分布式协调服务对比 🌐

“并发控制如同交响乐团的指挥，CountDownLatch就是那根精准的指挥棒” —— 来自一位凌晨三点debug的程序员 🎻💻