并发工具全解：CountDownLatch、CyclicBarrier、Semaphore、Phaser

public class ServiceBootstrap {
    private static final int SERVICE_COUNT = 5;

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(SERVICE_COUNT);

        for (int i = 0; i < SERVICE_COUNT; i++) {
            final int idx = i;
            new Thread(() -> {
                initService(idx);           // 模拟服务初始化
                latch.countDown();          // 完成一个，计数减 1
                System.out.println("服务" + idx + " 初始化完毕");
            }, "init-thread-" + i).start();
        }

        latch.await();  // 主线程阻塞，直到 5 个服务全部初始化
        System.out.println("所有服务就绪，系统启动完成！");
    }
}

CountDownLatch latch = new CountDownLatch(10);
AtomicInteger total = new AtomicInteger(0);

for (int i = 0; i < 10; i++) {
    executor.submit(() -> {
        total.addAndGet(fetchData());   // 每个线程拉取数据并累加
        latch.countDown();
    });
}

latch.await();                          // 等待全部完成
System.out.println("汇总结果: " + total.get());

private static final class Sync extends AbstractQueuedSynchronizer {
    Sync(int count) { setState(count); }  // AQS state = 计数值

    protected int tryAcquireShared(int acquires) {
        return (getState() == 0) ? 1 : -1;  // state==0 获取成功，否则阻塞
    }

    protected boolean tryReleaseShared(int releases) {
        for (;;) {
            int c = getState();
            if (c == 0) return false;
            int nextc = c - 1;
            if (compareAndSetState(c, nextc))
                return nextc == 0;  // 减到 0 才释放所有 await 线程
        }
    }
}

public class MatrixCalculator {
    static final int THREADS = 4;
    // 所有线程到齐后，执行一次 barrierAction（如打印日志）
    static CyclicBarrier barrier = new CyclicBarrier(THREADS, () ->
        System.out.println("第 " + round + " 轮计算完毕，进入下一轮"));

    static int round = 0;

    public static void main(String[] args) {
        for (int i = 0; i < THREADS; i++) {
            new Thread(() -> {
                for (int r = 0; r < 3; r++) {
                    computePartition();          // 计算自己负责的分块
                    try {
                        barrier.await();         // 等待其他线程完成本轮
                    } catch (Exception e) { return; }
                    // ★ 屏障打开后，所有线程同时进入下一轮
                }
            }).start();
        }
    }
}

public class CyclicBarrier {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition trip = lock.newCondition();
    private final int parties;          // 参与者数量（不可变）
    private int count;                  // 已到达的线程数
    private int generation = 0;          // 代数：每次 reset 递增，防止旧 await 误唤醒
    private final Runnable barrierCommand; // 屏障动作（可选）

    public int await() throws ... {
        lock.lock();
        try {
            int g = generation;
            int index = --count;        // 到达计数减 1
            if (index == 0) {           // ★ 最后一个到达的线程
                if (barrierCommand != null) barrierCommand.run();
                nextGeneration();        // 唤醒所有线程，重置 count，generation++
                return 0;
            }
            // 不是最后一个：挂起等待
            while (g == generation)
                trip.await();            // 在 Condition 上等待
            return index;
        } finally { lock.unlock(); }
    }
}

public class DbPool {
    // 最多允许 10 个线程同时获取连接
    private static final Semaphore semaphore = new Semaphore(10);

    public ResultSet query(String sql) throws InterruptedException {
        semaphore.acquire();               // 获取许可，不够则阻塞
        try {
            return executeQuery(sql);      // 执行数据库操作
        } finally {
            semaphore.release();           // ★ 必须归还，否则许可泄漏！
        }
    }
}

// 令牌桶简化版：Semaphore + 定时补充
Semaphore rateLimiter = new Semaphore(100);

// 定时任务每秒补满许可
scheduler.scheduleAtFixedRate(() -> {
    int available = rateLimiter.availablePermits();
    if (available < 100)
        rateLimiter.release(100 - available);  // 补充到 100
}, 1, 1, TimeUnit.SECONDS);

// 请求处理
if (rateLimiter.tryAcquire()) {   // 非阻塞尝试
    handleRequest();
} else {
    rejectWith429();                 // 限流拒绝
}

// 非公平（默认）：允许"插队"，吞吐量高
Semaphore unfair = new Semaphore(10);

// 公平：严格按排队顺序获取许可
Semaphore fair = new Semaphore(10, true);

protected int tryAcquireShared(int acquires) {
    for (;;) {
        int available = getState();
        int remaining = available - acquires;
        // remaining < 0 → 许可不足，获取失败 → 入队 park
        // CAS 成功 → 扣减许可，获取成功
        if (remaining < 0 || compareAndSetState(available, remaining))
            return remaining;
    }
}

protected boolean tryReleaseShared(int releases) {
    for (;;) {
        int current = getState();
        int next = current + releases;
        if (compareAndSetState(current, next))
            return true;   // release 总是成功，唤醒等待线程
    }
}

public class IterativeSolver {
    static final int MAX_ROUNDS = 100;

    public static void main(String[] args) {
        Phaser phaser = new Phaser(1); // 主线程先注册

        for (int i = 0; i < 4; i++) {
            phaser.register();             // 动态注册工作线程
            new Thread(() -> {
                for (int r = 0; r < MAX_ROUNDS; r++) {
                    compute();
                    phaser.arriveAndAwaitAdvance(); // 到达并等待本轮所有线程
                    // 某些线程可能提前 deregister()
                }
                phaser.arriveAndDeregister();       // 完成后注销
            }).start();
        }

        phaser.arriveAndDeregister(); // 主线程注销
    }
}