JDK Synchronizers 设计及工作原理与教程

针对 JDK 同步器（Synchronizers），从设计思想、核心工作原理、分类与使用教程三个维度，为你构建一份系统性的技术指南。

一、 总体设计思想：AQS 框架

JDK 中几乎所有的同步器（ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier等）底层都基于AbstractQueuedSynchronizer（AQS）构建。理解 AQS 就等于理解了 JDK 同步器的半壁江山。

AQS 核心三要素：

1. 状态变量（state）：一个volatile int state，用于表示共享资源的状态。例如：

   • ReentrantLock：state=0表示未锁定，>0表示重入次数。

   • Semaphore：state表示剩余许可数。

2. CLH 队列（双向链表）：一个先进先出（FIFO）的等待队列，用于存放争抢资源失败而被阻塞的线程。

3. 两种资源共享模式：

   • 独占模式（Exclusive）：同一时刻只有一个线程能持有资源（如ReentrantLock）。

   • 共享模式（Shared）：多个线程可同时持有资源（如Semaphore、CountDownLatch）。

AQS 设计精髓（模板方法模式）：
AQS 不直接实现同步逻辑，而是定义了获取/释放资源的骨架流程（如acquire()、release()），并将具体如何检查状态、修改状态留给子类实现（tryAcquire、tryRelease）。

二、 核心工作原理（以 ReentrantLock 为例）

我们以非公平锁的lock()和unlock()为例，拆解 AQS 的运行机制：

1. 加锁流程（lock）：

   • 线程调用lock()，AQS 调用子类的tryAcquire()。

   • 检查state：

     • 若state == 0，通过 CAS 将state置为 1，并设置当前线程为独占所有者 →加锁成功。

     • 若state > 0且当前线程就是所有者，state++（重入）→加锁成功。

     • 否则 →加锁失败，将该线程封装成 Node 节点，加入 CLH 队列尾部。

   • 入队后的线程执行park()阻塞，等待前驱节点唤醒。

2. 解锁流程（unlock）：

   • 调用unlock()，调用子类的tryRelease()，将state减 1。

   • 若state减为 0，清空独占所有者。

   • 唤醒 CLH 队列中的下一个有效节点（unpark()）。

   • 被唤醒的线程重新尝试tryAcquire()。

关键优化：非公平锁在尝试tryAcquire前，会直接先进行一次 CAS 抢锁（插队），提升吞吐量但可能导致饥饿。

三、 常用同步器分类与工作机制（速查表）

四、 使用教程与最佳实践（含代码示例）

1. ReentrantLock（替代 synchronized）

// 推荐用法：务必在 finally 中释放 private final ReentrantLock lock = new ReentrantLock(); public void doSomething() { lock.lock(); try { // 业务逻辑（支持 lockInterruptibly、tryLock 等高级特性） } finally { lock.unlock(); } }

2. Semaphore（限流 / 连接池控制）

// 模拟允许最多 3 个并发请求 Semaphore semaphore = new Semaphore(3); for (int i = 0; i < 10; i++) { new Thread(() -> { try { semaphore.acquire(); // 获取许可，阻塞直到有可用 System.out.println(Thread.currentThread().getName() + " 执行"); Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { semaphore.release(); // 释放许可 } }).start(); }

3. CountDownLatch（主线程等待子任务完成）

CountDownLatch latch = new CountDownLatch(3); // 启动 3 个子线程 for (int i = 0; i < 3; i++) { new Thread(() -> { // 执行任务... latch.countDown(); // 完成一个，计数减 1 }).start(); } latch.await(); // 主线程阻塞，直到计数为 0 System.out.println("所有任务完成");

4. CyclicBarrier（多线程互相等待，一起进行下一轮）

// 允许 3 个线程互相等待，全部到达后一起执行 barrierAction CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("全员到达，继续下一轮")); for (int i = 0; i < 3; i++) { new Thread(() -> { try { System.out.println(Thread.currentThread().getName() + " 到达"); barrier.await(); // 等待其他线程 System.out.println(Thread.currentThread().getName() + " 继续执行"); } catch (Exception ignored) {} }).start(); }

五、 高级避坑指南（重要）

1. 中断响应：使用lockInterruptibly()而非lock()，以便在等待锁时响应中断。

2. 避免await()在循环外使用：Condition的await()必须放在while (条件不满足)循环中，防止虚假唤醒。

3. CountDownLatch 不可重用：计数减到 0 后无法重置。如需重用，请用CyclicBarrier。

4. 读写锁的锁降级：写锁可以降级为读锁（先获取写锁，再获取读锁，再释放写锁），但读锁不能升级为写锁。

5. 性能考量：非公平锁吞吐量通常更高，除非强需求避免使用公平锁。

六、 学习路径建议

1. 初级：熟练使用ReentrantLock+Condition实现等待/通知，掌握Semaphore做限流。

2. 中级：精读 AQS 源码中的acquireQueued()和shouldParkAfterFailedAcquire()，理解节点状态流转（SIGNAL、CANCELLED）。

3. 高级：尝试基于 AQS 自定义一个互斥锁（只需实现tryAcquire和tryRelease），这能让你彻底理解模板方法模式。