← 返回首页 📚 实战课程
📑 本篇章节导航 (共4章,点击直达)
一、理论篇(30%)—— AQS源码级拆解二、动手篇(40%)—— 手写简化版ReentrantLock和CountDownLatch三、面试模拟篇(20%)—— 追问链式考核四、练习篇(10%)

P1-02 - AQS完整原理与手写实现

定位:你知道AQS是CLH队列+state,面试也能说个大概。但面试官问"waitStatus每个值的含义""unparkSuccessor为什么要从tail往前找""手写一个ReentrantLock",你就卡住了。本节专治这个gap。

一、理论篇(30%)—— AQS源码级拆解

1.1 CLH队列节点结构


// AQS内部类 Node 的核心字段
static final class Node {
    // ======== waitStatus 值(面试必背) ========
    static final int CANCELLED  =  1;  // 线程被取消(超时/中断)
    static final int SIGNAL     = -1;  // 后继节点需要被唤醒
    static final int CONDITION  = -2;  // 在Condition队列中
    static final int PROPAGATE  = -3;  // 共享模式传播唤醒

    volatile int waitStatus;
    volatile Node prev;       // 前驱节点(CLH队列是双向链表)
    volatile Node next;       // 后继节点
    volatile Thread thread;   // 等待的线程
    Node nextWaiter;          // Condition队列的下一个节点 / 模式标记

    // isShared():nextWaiter == SHARED 表示共享模式
}

waitStatus 状态转换图(面试画图题):


初始化:waitStatus = 0

独占模式获取:
  0 ──[enq入队]──→ 前驱设为SIGNAL(-1) ──[shouldParkAfterFailedAcquire]──→ park
                                                                            │
  CANCELLED(1) ←──[超时/中断]──────────────────────────────────────────────┘

共享模式获取:
  0 ──[入队]──→ SIGNAL(-1) ──[被唤醒]──→ PROPAGATE(-3)(传播唤醒后继)

Condition队列:
  入队时设为CONDITION(-2),signal后移回CLH队列设为0

1.2 独占模式:acquire/release 完整流程


acquire(int arg) 流程(ReentrantLock.lock()的底层):

tryAcquire(arg)  ──成功──→  返回(获取到锁)
       │
      失败
       │
       ▼
addWaiter(Node.EXCLUSIVE)  ──→  创建Node并入队CLH尾部
       │
       ▼
acquireQueued(node, arg)  ──→  自旋/park等待
       │
       ├── 前驱是head && tryAcquire成功 → 设为head,返回
       │
       └── shouldParkAfterFailedAcquire
              │
              ├── 前驱ws == SIGNAL → 安全park → LockSupport.park(this)
              │
              ├── 前驱ws > 0 (CANCELLED) → 跳过已取消节点
              │
              └── 前驱ws == 0 → CAS设为SIGNAL → 下一轮再park

release(int arg) 流程:

tryRelease(arg)  ──失败──→  返回false
       │
      成功
       │
       ▼
head != null && head.waitStatus != 0 ?
       │
      是
       │
       ▼
unparkSuccessor(head)
       │
       ├── ws < 0 → CAS将ws设为0
       │
       ├── s.next != null && s.waitStatus <= 0 → LockSupport.unpark(s.thread)
       │
       └── next为空或已取消 → 从tail往前遍历找到最近的未取消节点

面试重点:为什么要从tail往前遍历?
→ 因为enq()中是先设置node.prev = pred,再CAS设置tail,最后才设置pred.next = node
→ 如果从head往后遍历,可能漏掉刚入队但next还没设置的节点
→ 从tail往前遍历,prev指针是入队时就设置好的,保证不会遗漏

1.3 共享模式:acquireShared/releaseShared


acquireShared(int arg):

tryAcquireShared(arg)
  返回值 < 0  → 获取失败,入队等待
  返回值 >= 0 → 获取成功

  如果获取成功 && head.waitStatus是SIGNAL/PROPAGATE
  → doReleaseShared() 传播唤醒后继共享节点

releaseShared(int arg):

tryReleaseShared(arg) → true
  │
  ▼
doReleaseShared():
  循环从head开始:
    ws == SIGNAL → CAS设为0 → unpark后继
    ws == 0 → CAS设为PROPAGATE(确保后续获取能传播)
    如果head没变 → 跳出循环;变了 → 继续

1.4 Condition队列:await/signal


ConditionObject 维护一个单向链表(firstWaiter → lastWaiter)

await() 流程:
1. addConditionWaiter() → 创建新Node(ws=CONDITION),加入Condition队列尾部
2. fullyRelease(node) → 释放锁(调用release),唤醒CLH队列中的后继
3. while(!isOnSyncQueue(node)) → park等待
4. 被唤醒后 → acquireQueued() 重新获取锁

signal() 流程:
1. firstWaiter != null
2. transferForSignature(firstWaiter)
   → CAS将ws从CONDITION改为0
   → enq(node) 将节点从Condition队列移到CLH队列尾部
   → 如果前驱已取消或CAS设置SIGNAL失败 → LockSupport.unpark(node.thread)
3. firstWaiter = firstWaiter.nextWaiter

二、动手篇(40%)—— 手写简化版ReentrantLock和CountDownLatch

2.1 手写简化版ReentrantLock(完整可编译)


import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 手写简化版 ReentrantLock —— 基于AQS模板方法
 *
 * 只实现核心功能:lock / unlock / tryLock / newCondition
 * 不实现公平锁、中断、超时等高级特性
 */
public class SimpleReentrantLock implements Lock {

    private final Sync sync;

    public SimpleReentrantLock() {
        this.sync = new Sync();
    }

    // ========== AQS核心实现 ==========
    private static class Sync extends AbstractQueuedSynchronizer {

        /**
         * 尝试获取锁(独占模式)
         *
         * state含义:
         *   0  → 未锁定
         *   >0 → 锁定,值=重入次数
         */
        @Override
        protected boolean tryAcquire(int arg) {
            Thread current = Thread.currentThread();
            int c = getState();

            if (c == 0) {
                // 无锁状态,CAS尝试获取(非公平)
                if (compareAndSetState(0, arg)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            } else if (current == getExclusiveOwnerThread()) {
                // 当前线程已持有锁 → 重入
                int nextc = c + arg;
                if (nextc < 0) {
                    throw new Error("Maximum lock count exceeded");
                }
                setState(nextc);
                return true;
            }
            return false;
        }

        /**
         * 尝试释放锁
         */
        @Override
        protected boolean tryRelease(int arg) {
            int c = getState() - arg;
            if (Thread.currentThread() != getExclusiveOwnerThread()) {
                throw new IllegalMonitorStateException("非锁持有线程尝试释放");
            }
            boolean free = false;
            if (c == 0) {
                // 完全释放
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c); // 注意:这里不需要CAS,因为只有持有锁的线程才能释放
            return free;
        }

        @Override
        protected boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        Condition newCondition() {
            return new ConditionObject();
        }
    }

    // ========== Lock接口实现 ==========

    @Override
    public void lock() {
        sync.acquire(1);
    }

    @Override
    public void unlock() {
        sync.release(1);
    }

    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }

    // 以下方法简化实现,不在本节重点
    @Override public void lockInterruptibly() throws InterruptedException {
        throw new UnsupportedOperationException("简化版未实现");
    }
    @Override public boolean tryLock(long time, java.util.concurrent.TimeUnit unit)
            throws InterruptedException {
        throw new UnsupportedOperationException("简化版未实现");
    }
}

2.2 手写简化版CountDownLatch


import java.util.concurrent.locks.AbstractQueuedSynchronizer;

/**
 * 手写简化版 CountDownLatch —— 基于AQS共享模式
 *
 * state含义:剩余计数(每次countDown减1,减到0时唤醒所有等待线程)
 */
public class SimpleCountDownLatch {

    private final Sync sync;

    public SimpleCountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        sync = new Sync(count);
    }

    private static class Sync extends AbstractQueuedSynchronizer {

        Sync(int count) {
            setState(count);
        }

        /**
         * 共享模式获取:state == 0 时返回正数(允许),否则返回-1(阻塞)
         *
         * 这里返回值含义:
         *   负数 → 获取失败,需要入队等待
         *   零   → 获取成功,但不传播
         *   正数 → 获取成功,且传播唤醒后继
         */
        @Override
        protected int tryAcquireShared(int arg) {
            return getState() == 0 ? 1 : -1;
        }

        /**
         * 共享模式释放:将state减1,减到0返回true
         */
        @Override
        protected boolean tryReleaseShared(int arg) {
            for (;;) {
                int c = getState();
                if (c == 0) return false; // 已经是0,不需要再减
                int nextc = c - 1;
                if (compareAndSetState(c, nextc)) {
                    return nextc == 0; // 减到0时返回true,触发doReleaseShared
                }
            }
        }
    }

    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    public void countDown() {
        sync.releaseShared(1);
    }

    public long getCount() {
        return sync.getState();
    }
}

2.3 验证手写的锁和计数器


/**
 * 测试手写的 SimpleReentrantLock 和 SimpleCountDownLatch
 */
public class AqsDemo {

    public static void testReentrantLock() throws Exception {
        SimpleReentrantLock lock = new SimpleReentrantLock();
        int[] counter = {0};

        // 测试重入性
        lock.lock();
        lock.lock(); // 重入
        try {
            counter[0]++;
            System.out.println("重入成功,counter=" + counter[0]);
        } finally {
            lock.unlock();
            lock.unlock(); // 需要解锁两次
        }

        // 测试多线程互斥
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                lock.lock();
                try {
                    counter[0]++;
                } finally {
                    lock.unlock();
                }
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("最终 counter=" + counter[0]); // 期望2001(1 + 2000)
    }

    public static void testCountDownLatch() throws Exception {
        SimpleCountDownLatch latch = new SimpleCountDownLatch(3);

        for (int i = 0; i < 3; i++) {
            final int idx = i;
            new Thread(() -> {
                try { Thread.sleep(1000 * (idx + 1)); } catch (Exception e) {}
                System.out.println("线程 " + idx + " 完成,剩余=" + latch.getCount());
                latch.countDown();
            }).start();
        }

        System.out.println("主线程等待...");
        latch.await();
        System.out.println("所有线程完成");
    }

    public static void main(String[] args) throws Exception {
        testReentrantLock();
        System.out.println("---");
        testCountDownLatch();
    }
}

2.4 AQS队列可视化实验


import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;

/**
 * 通过反射观察AQS内部队列状态
 * 验证CLH队列在竞争时的节点变化
 */
public class AqsQueueVisualizer {

    public static void main(String[] args) throws Exception {
        ReentrantLock lock = new ReentrantLock();

        // 主线程持有锁
        lock.lock();

        // 启动3个等待线程
        Thread[] waiters = new Thread[3];
        for (int i = 0; i < 3; i++) {
            final int idx = i;
            waiters[i] = new Thread(() -> {
                lock.lock();
                try {
                    System.out.println("线程" + idx + "获得锁");
                    Thread.sleep(500);
                } catch (Exception e) {
                } finally {
                    lock.unlock();
                }
            }, "Waiter-" + i);
            waiters[i].start();
            Thread.sleep(100); // 确保依次入队
        }

        // 此时CLH队列:head → Waiter-0 → Waiter-1 → Waiter-2 → tail
        // 使用jstack观察这些线程的状态(都是BLOCKED/LockSupport.park)

        System.out.println("使用jstack " + ProcessHandle.current().pid() + " 观察队列");
        Thread.sleep(10000);

        lock.unlock(); // 唤醒第一个等待者
        for (Thread t : waiters) t.join();
    }
}

三、面试模拟篇(20%)—— 追问链式考核

Q1: AQS的核心设计是什么?

追问链:


Q1.1: state为什么用volatile int而不用AtomicInteger?
→ state的CAS操作通过Unsafe.compareAndSwapInt直接完成
→ volatile保证可见性,CAS保证原子性,不需要AtomicInteger的额外开销
→ 且AQS需要灵活地做 condition check + CAS 的组合,AtomicInteger的API不够

Q1.2: CLH队列为什么用双向链表?单向不行吗?
→ 双向链表支持从tail向前遍历(unparkSuccessor需要)
→ 取消节点时需要断开prev/next指针,双向链表更方便
→Condition.signal时需要检查节点是否在SyncQueue上,需要prev指针

Q1.3: AQS的模板方法模式体现在哪里?
→ AQS定义了acquire/release的骨架(入队、park、unpark)
→ 子类只需实现tryAcquire/tryRelease定义"能否获取/释放"
→ 类比:AQS是"排队系统",子类是"业务规则"

Q2: unparkSuccessor为什么要从tail往前遍历?

追问链:


Q2.1: enq入队时,prev和next的设置顺序是什么?
→ node.prev = pred(第一步)
→ CAS(tail, pred, node)(第二步)
→ pred.next = node(第三步)
→ 所以prev先于next被设置

Q2.2: 如果从head往后遍历会怎样?
→ 可能遇到刚入队但next还没设置的节点,认为没有后继,导致漏唤醒
→ 从tail往前遍历,prev已经设置,不会遗漏

Q2.3: 这是不是一个并发bug?
→ 不是bug,是设计上的权衡
→ 入队的"窗口期"内next可能为null,但prev一定已设置
→ 所以从tail遍历是正确的做法

Q3: CountDownLatch和CyclicBarrier的区别?

追问链:


Q3.1: 它们底层分别怎么实现的?
→ CountDownLatch基于AQS共享模式,state=计数器
→ CyclicBarrier基于ReentrantLock + Condition,内部维护count和parties

Q3.2: 为什么CountDownLatch用共享模式?
→ 因为await()可能同时有多个线程等待
→ state减到0时,需要一次性唤醒所有等待线程(doReleaseShared传播唤醒)
→ 如果用独占模式,只能唤醒一个

Q3.3: CyclicBarrier为什么能重置?
→ 它不是基于AQS的state,而是自己维护的count
→ 所有线程到达后,调用reset()将count恢复为parties
→ Generation机制处理重置期间的边界情况

常见踩坑

1. 以为AQS队列是先进先出就公平 —— 错,非公平锁的tryAcquire可以在队列线程被唤醒前"插队"

2. 以为waitStatus的初始值是SIGNAL —— 错,初始是0,入队后通过shouldParkAfterFailedAcquire才设为SIGNAL

3. 以为Condition await()不释放锁 —— 错,await()会调用fullyRelease()释放锁

4. 以为 park 后线程状态是 BLOCKED —— 错,是 WAITING(LockSupport.park)

5. 手写tryRelease时忘记检查当前线程是否是持有者 —— 导致任何线程都能释放锁


四、练习篇(10%)

练习1:手写公平锁

基于SimpleReentrantLock,改造为公平锁版本。

提示:公平锁在tryAcquire时需要先检查 hasQueuedPredecessors()。

练习2:手写Semaphore

基于AQS共享模式,手写一个简单的Semaphore。

提示:tryAcquireShared中 state - arg >= 0 时返回剩余许可,否则返回-1。

练习3:用Condition实现交替打印

使用ReentrantLock + 两个Condition,实现线程A打印奇数、线程B打印偶数,交替输出1-100。

练习4:源码追踪

打开JDK源码,跟踪 ReentrantLock.lock() 的完整调用链:

lock() → sync.acquire(1) → tryAcquire(1) → compareAndSetState(0,1)

画出方法调用时序图,标注每一步的类和方法名。