并发工具全解：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(() -> {
                try {
                    initService(idx);      // 模拟服务初始化
                } finally {
                    latch.countDown();     // ★ finally 里减，防止异常导致计数漏减
                }
            }, "init-thread-" + i).start();
        }

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

    static void initService(int idx) {
        try {
            Thread.sleep(300 + idx * 100L);  // 模拟耗时初始化
            System.out.println("服务 " + idx + " 初始化完毕");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

public class PressureTestStarter {
    public static void main(String[] args) throws InterruptedException {
        final int WORKERS = 10;
        CountDownLatch startGun = new CountDownLatch(1);  // 发令枪：初始 1

        for (int i = 0; i < WORKERS; i++) {
            new Thread(() -> {
                try {
                    startGun.await();          // 全部待命，谁都不先跑
                    sendRequests();            // 听到枪响，同时开始发压测请求
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }, "worker-" + i).start();
        }

        Thread.sleep(1000);          // 主线程做准备（预热、建连接）
        System.out.println("预备——跑！");
        startGun.countDown();                 // 计数 1 → 0，10 个线程同时起跑
    }
}

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

    protected int tryAcquireShared(int acquires) {
        return (getState() == 0) ? 1 : -1;  // state==0 放行，否则加入等待队列
    }

    protected boolean tryReleaseShared(int releases) {
        for (;;) {                         // 自旋 CAS，保证并发 countDown 原子性
            int c = getState();
            if (c == 0) return false;      // 已经到 0，无需再释放
            int nextc = c - 1;
            if (compareAndSetState(c, nextc))
                return nextc == 0;         // ★ 只有减到 0 的那次才返回 true
        }
    }
}

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.atomic.AtomicInteger;

public class IterationSync {
    static final int THREADS = 3;
    static final AtomicInteger round = new AtomicInteger(1);

    // 所有线程到齐后，由最后一个到达的线程执行 barrierAction
    static final CyclicBarrier barrier = new CyclicBarrier(THREADS, () ->
        System.out.println("── 第 " + round.getAndIncrement() + " 轮结束，所有人到齐 ──"));

    public static void main(String[] args) {
        for (int i = 0; i < THREADS; i++) {
            final int tid = i;
            new Thread(() -> {
                try {
                    for (int r = 0; r < 3; r++) {
                        computePartition(tid);              // 算自己负责的分块
                        int index = barrier.await(); // 到齐才放行；返回到达序号
                        // 屏障打开：所有线程同时进入下一轮
                    }
                } catch (BrokenBarrierException e) {
                    System.out.println("barrier 被破坏：" + e);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }, "worker-" + i).start();
        }
    }

    static void computePartition(int tid) {
        try {
            Thread.sleep(100 + tid * 50L);  // 模拟分块计算，耗时各不相同
            System.out.println("worker-" + tid + " 完成一块");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

public class CyclicBarrier {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition trip = lock.newCondition();
    private final int parties;          // 参与者总数（构造时定死）
    private int count;                  // 还差几个到齐（从 parties 往下减）
    private int generation = 0;          // 代数：每轮 +1，防止旧轮线程误唤醒
    private final Runnable barrierCommand; // 可选的 barrierAction

    public int await() throws InterruptedException, BrokenBarrierException {
        lock.lock();
        try {
            if (broken) throw new BrokenBarrierException();
            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 rateLimiter = new Semaphore(100);

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

// 请求处理：抢不到许可立刻降级，别让请求干等
if (rateLimiter.tryAcquire()) {   // 非阻塞尝试
    handleRequest();
} else {
    rejectWith429();                 // 限流拒绝
}

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

// 公平：严格按排队顺序获取许可（FIFO），适合对公平性敏感的场景
Semaphore fair = new Semaphore(10, true);

protected int tryAcquireShared(int acquires) {
    for (;;) {
        int available = getState();
        int remaining = available - acquires;
        // remaining < 0 → 许可不足，获取失败 → AQS 入队 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 几乎总是成功，并唤醒等待线程
    }
}

import java.util.concurrent.Phaser;

public class DynamicSolver {
    static final int ROUNDS = 5;

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

        for (int i = 0; i < 4; i++) {
            phaser.register();            // 每来一个工作线程，动态注册 +1
            new Thread(() -> {
                for (int r = 0; r < ROUNDS; r++) {
                    compute();                       // 干活
                    phaser.arriveAndAwaitAdvance();  // 到达本阶段并等齐
                }
                phaser.arriveAndDeregister();  // 干完活：到达并注销自己（参与数 -1）
            }, "worker-" + i).start();
        }

        while (phaser.getRegisteredParties() > 1) {  // 主线程盯进度
            phaser.arriveAndAwaitAdvance();          // 每轮也跟着对齐
        }
        System.out.println("所有轮次完成，主线程收工");
    }

    static void compute() {
        try {
            Thread.sleep(50);   // 模拟计算
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// 位布局（从低位到高位）：
//   bits 0-15   : unarrived  当前阶段还没到达的人数
//   bits 16-31  : parties    总参与人数
//   bits 32-62  : phase      阶段号（从 0 递增）
//   bit  63     : terminated 是否已终止（1 = 终止）
private volatile long state;

// 例：参与 4 人、已到 3 人、当前第 2 阶段
// state = 0x00000002_00040003（示意）
//         phase=2  parties=4  unarrived=3

import java.util.concurrent.Exchanger;
import java.util.ArrayList;
import java.util.List;

public class BufferSwap {
    public static void main(String[] args) {
        Exchanger<List<Integer>> exchanger = new Exchanger<>();

        new Thread(() -> {                        // 生产者
            List<Integer> buf = new ArrayList<>();
            try {
                for (int i = 0; i < 10; i++) {
                    buf.add(i);                    // 攒一批数据
                    if (buf.size() == 5) {
                        buf = exchanger.exchange(buf);  // 满 5 个就交换，换回空 buffer
                    }
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "producer").start();

        new Thread(() -> {                        // 消费者
            List<Integer> buf = new ArrayList<>();
            try {
                for (int i = 0; i < 2; i++) {
                    buf = exchanger.exchange(buf);   // 换回装满的 buffer
                    System.out.println("消费者处理: " + buf);  // 处理
                    buf.clear();                     // 清空再换回去
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "consumer").start();
    }
}