AQS 的原理是什么？CountDownLatch、Semaphore、CyclicBarrier 怎么用？

AbstractQueuedSynchronizer
├── volatile int state       含义由子类决定：重入次数、剩余许可、剩余计数……；独占模式下另外记录持有者线程
└── 等待队列（双向链表）
    head（哑节点或当前持有者）⇄ Node(T2, 等待中) ⇄ Node(T3, 等待中) ⇄ ... ⇄ tail

acquire(arg):  while (!tryAcquire(arg)) { 没入队就入队；可能挂起当前线程 }
release(arg):  if (tryRelease(arg)) { 唤醒队列中的第一个等待线程 }

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SyncToolsDemo { // 需要 JDK 21：用到了虚拟线程
    public static void main(String[] args) throws InterruptedException {
        // 1. Semaphore + CountDownLatch：100 个任务，最多 3 个同时调用下游，主线程等全部结束
        Semaphore permits = new Semaphore(3);
        CountDownLatch done = new CountDownLatch(100);
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
        for (int i = 0; i < 100; i++) {
            executor.submit(() -> {
                try {
                    permits.acquire(); // 没有许可就挂起，虚拟线程会让出载体线程
                    try {
                        Thread.sleep(10); // 模拟调用下游
                    } finally {
                        permits.release(); // 拿到了许可才归还，所以放在内层 finally
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    done.countDown(); // 不管成功失败都要减，否则 await 永远等不到 0
                }
            });
        }
        done.await();
        executor.shutdown();

        // 2. CyclicBarrier：3 个线程分 2 个阶段，每个阶段 3 个线程都到达后才打印汇总行，再进入下一阶段
        CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("--- 本阶段全部完成 ---"));
        Thread[] workers = new Thread[3];
        for (int i = 0; i < workers.length; i++) {
            int id = i;
            workers[i] = Thread.ofVirtual().start(() -> {
                try {
                    for (int phase = 1; phase <= 2; phase++) {
                        System.out.println("worker-" + id + " 完成阶段 " + phase);
                        barrier.await(); // 到齐前在这里等；到齐后屏障自动复位，下一阶段接着用
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } catch (BrokenBarrierException e) {
                    System.out.println("有线程中断或超时，屏障被打破");
                }
            });
        }
        for (Thread t : workers) t.join();
    }
}