java并发编程（五）ReetrantLock源码分析

一、继承结构

非公平锁继承结构：

公平锁继承结构：

公平锁内部是FairSync,非公平锁内部是NonfairSync。而不管是FairSync还是NonfariSync,都间接继承自AbstractQueuedSynchronizer这个抽象类。

二、AQS类的设计思想

可以把 AQS 比作一个「同步器模板」：

• 它定义了多线程竞争「共享资源」的核心规则（比如 "谁先获取资源""获取不到资源的线程怎么等""释放资源后怎么唤醒等待线程"）；
• 子类只需实现少量抽象方法（比如 tryAcquire、tryRelease），就能快速定制出不同的同步器（比如 "独占锁""共享锁"），无需重复编写队列、线程挂起 / 唤醒等底层逻辑。

AQS 的核心是「状态管理 + 等待队列 + 模板方法」，解决了并发编程中最核心的 "资源竞争与等待" 问题：

1. 共享资源的状态管理 ：用一个 volatile int state 变量表示资源状态（比如锁的持有状态、信号量的许可数），通过 CAS 保证状态修改的原子性；
2. 等待队列（CLH 队列）：获取不到资源的线程会被封装成「节点」，加入双向链表（CLH 队列）中挂起，避免忙等；
3. 模板方法模式：AQS 定义了获取 / 释放资源的核心流程（模板方法），子类只需实现 "尝试获取资源""尝试释放资源" 的具体逻辑（钩子方法）。

1.state变量

表示资源状态（比如锁的持有状态、信号量的许可数），通过 CAS 保证状态修改的原子性；

// AQS 核心状态变量，volatile 保证可见性，CAS 保证原子性
private volatile int state;

// 获取状态（线程安全）
protected final int getState() { return state; }
// 设置状态（仅子类可调用）（仅适合无并发场景）
protected final void setState(int newState) { state = newState; }
// CAS 修改状态（核心，保证原子性）
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

用途 ：不同子类对 state 的语义定义不同：

• ReentrantLock：state=0 表示无锁，state>0 表示锁的重入次数；
• Semaphore：state 表示可用的许可数；
• CountDownLatch：state 表示计数器的值。

2. 等待队列：CLH 双向链表

 private transient volatile Node head;

 private transient volatile Node tail;

之后分析过程中所说的 queue，也就是阻塞队列不包含 head，不包含 head，不包含 head。

每个节点（Node）包含核心属性：

解释一下独占和共享模式：

• 独占模式：同一时刻只有一个线程 能成功获取同步状态state，0 = 无锁，≥1 = 加锁 / 重入次数，其他尝试获取的线程会被封装为节点入 CLH 队列阻塞等待，直到持有锁的线程释放状态。释放后仅唤醒后继 1 个节点 ，无传播。因为 ReentrantLock 是独占锁，所以其基于 AQS 实现时，必须全程使用独占模式
• 共享模式：同一时刻允许多个线程获取state，共享性，state表示可用资源数 / 许可数 / 计数器值 / 读线程数，获取 / 释放成功后链式唤醒后续所有共享节点。

static final class Node {
    // 节点模式：独占（比如 ReentrantLock）
    static final Node EXCLUSIVE = null;
    // 节点模式：共享（比如 Semaphore、CountDownLatch）
    static final Node SHARED = new Node();
    
    // 等待状态：取消（线程放弃等待）
    static final int CANCELLED =  1;
    // 等待状态：后继节点需要被唤醒
    static final int SIGNAL    = -1;
    // 等待状态：线程在条件队列中
    static final int CONDITION = -2;
    // 等待状态：共享模式下，状态会传播
    static final int PROPAGATE = -3;

    // 节点的等待状态（volatile 修饰）
/*
0:初始化状态；
-1(SIGNAL):当前结点表示的线程在释放锁后需要唤醒后续节点的线程;
1(CANCELLED):在同步队列中等待的线程等待超时或者被中断,取消继续等待。
*/
    volatile int waitStatus;
    // 前驱节点
    volatile Node prev;
    // 后继节点
    volatile Node next;
    // 当前结点表示的线程,因为同步队列中的结点内部封装了之前竞争锁失败的线程,故而结点内部必然有一个对应线程实例的引用
    volatile Thread thread;
    // 下一个等待条件的节点（条件队列用）
    Node nextWaiter;
}

• 队列头节点是「已获取资源的线程」，其他节点是「等待资源的线程」；
• 线程获取资源失败时，会被封装成 Node 加入队列尾部，然后挂起；
• 资源释放时，会唤醒头节点的后继节点，使其重新尝试获取资源。

3.exclusiveOwnerThread

该属性存在AbstractQueuedSynchronizer父类AbstractOwnableSynchronizer中：

/**
     * The current owner of exclusive mode synchronization.
     */
    private transient Thread exclusiveOwnerThread;

这是在独占同步模式下标记持有同步状态线程的。ReentrantLock就是典型的独占同步模式,该变量用来标识锁被哪个线程持有。

三、AQS源码解析

ReentrantLock 在内部用了内部类 Sync 来管理锁，所以真正的获取锁和释放锁是由 Sync 的实现类来控制的。

Sync 有两个实现，分别为 NonfairSync（非公平锁）和 FairSync（公平锁），我们看 FairSync 部分。

1.线程抢锁

static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;
      // 争锁
    final void lock() {
        acquire(1);
    }
      // 来自父类AQS，我直接贴过来这边，下面分析的时候同样会这样做，不会给读者带来阅读压力
    // 我们看到，这个方法，如果tryAcquire(arg) 返回true, 也就结束了。
    // 否则，acquireQueued方法会将线程压到队列中
    public final void acquire(int arg) { // 此时 arg == 1
        // 首先调用tryAcquire(1)一下，名字上就知道，这个只是试一试
        // 因为有可能直接就成功了呢，也就不需要进队列排队了，
        // 对于公平锁的语义就是：本来就没人持有锁，根本没必要进队列等待(又是挂起，又是等待被唤醒的)
        if (!tryAcquire(arg) &&
            // tryAcquire(arg)没有成功，这个时候需要把当前线程挂起，放到阻塞队列中。
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
              selfInterrupt();
        }
    }

    /**
     * Fair version of tryAcquire.  Don't grant access unless
     * recursive call or no waiters or is first.
     */
    // 尝试直接获取锁，返回值是boolean，代表是否获取到锁
    // 返回true：1.没有线程在等待锁；2.重入锁，线程本来就持有锁，也就可以理所当然可以直接获取
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        // state == 0 此时此刻没有线程持有锁
        if (c == 0) {
            // 虽然此时此刻锁是可以用的，但是这是公平锁，既然是公平，就得讲究先来后到，
            // 看看有没有别人在队列中等了半天了
            if (!hasQueuedPredecessors() &&
                // 如果没有线程在等待，那就用CAS尝试一下，成功了就获取到锁了，
                // 不成功的话，只能说明一个问题，就在刚刚几乎同一时刻有个线程抢先了 =_=
                // 因为刚刚还没人的，我判断过了
                compareAndSetState(0, acquires)) {
              
                // 到这里就是获取到锁了，标记一下，告诉大家，现在是我占用了锁
                setExclusiveOwnerThread(current);
                return true;
            }
        }
          // 会进入这个else if分支，说明是重入了，需要操作：state=state+1
        // 这里不存在并发问题
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        // 如果到这里，说明前面的if和else if都没有返回true，说明没有获取到锁
        // 回到上面一个外层调用方法继续看:
        // if (!tryAcquire(arg) 
        //        && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) 
        //     selfInterrupt();
        return false;
    }
  
    // 假设tryAcquire(arg) 返回false，那么代码将执行：
      //		acquireQueued(addWaiter(Node.EXCLUSIVE), arg)，
    // 这个方法，首先需要执行：addWaiter(Node.EXCLUSIVE)
  
    /**
     * Creates and enqueues node for current thread and given mode.
     *
     * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
     * @return the new node
     */
    // 此方法的作用是把线程包装成node，同时进入到队列中
    // 参数mode此时是Node.EXCLUSIVE，代表独占模式
    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        // 以下几行代码想把当前node加到链表的最后面去，也就是进到阻塞队列的最后
        Node pred = tail;
      
        // tail!=null => 队列不为空(tail==head的时候，其实队列是空的，不过不管这个吧)
        if (pred != null) { 
            // 将当前的队尾节点，设置为自己的前驱 
            node.prev = pred; 
            // 用CAS把自己设置为队尾, 如果成功后，tail == node 了，这个节点成为阻塞队列新的尾巴
            if (compareAndSetTail(pred, node)) { 
                // 进到这里说明设置成功，当前node==tail, 将自己与之前的队尾相连，
                // 上面已经有 node.prev = pred，加上下面这句，也就实现了和之前的尾节点双向连接了
                pred.next = node;
                // 线程入队了，可以返回了
                return node;
            }
        }
        // 仔细看看上面的代码，如果会到这里，
        // 说明 pred==null(队列是空的) 或者 CAS失败(有线程在竞争入队)
        // 读者一定要跟上思路，如果没有跟上，建议先不要往下读了，往回仔细看，否则会浪费时间的
        enq(node);
        return node;
    }
  
    /**
     * Inserts node into queue, initializing if necessary. See picture above.
     * @param node the node to insert
     * @return node's predecessor
     */
    // 采用自旋的方式入队
    // 之前说过，到这个方法只有两种可能：等待队列为空，或者有线程竞争入队，
    // 自旋在这边的语义是：CAS设置tail过程中，竞争一次竞争不到，我就多次竞争，总会排到的
    private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            // 之前说过，队列为空也会进来这里
            if (t == null) { // Must initialize
                // 初始化head节点
                // 细心的读者会知道原来 head 和 tail 初始化的时候都是 null 的
                // 还是一步CAS，你懂的，现在可能是很多线程同时进来呢
                if (compareAndSetHead(new Node()))
                    // 给后面用：这个时候head节点的waitStatus==0, 看new Node()构造方法就知道了
                  
                    // 这个时候有了head，但是tail还是null，设置一下，
                    // 把tail指向head，放心，马上就有线程要来了，到时候tail就要被抢了
                    // 注意：这里只是设置了tail=head，这里可没return哦，没有return，没有return
                    // 所以，设置完了以后，继续for循环，下次就到下面的else分支了
                    tail = head;
            } else {
                // 下面几行，和上一个方法 addWaiter 是一样的，
                // 只是这个套在无限循环里，反正就是将当前线程排到队尾，有线程竞争的话排不上重复排
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }
    
  
    // 现在，又回到这段代码了
    // if (!tryAcquire(arg) 
    //        && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) 
    //     selfInterrupt();
    
    // 下面这个方法，参数node，经过addWaiter(Node.EXCLUSIVE)，此时已经进入阻塞队列
    // 注意一下：如果acquireQueued(addWaiter(Node.EXCLUSIVE), arg))返回true的话，
    // 意味着上面这段代码将进入selfInterrupt()，所以正常情况下，下面应该返回false
    // 这个方法非常重要，应该说真正的线程挂起，然后被唤醒后去获取锁，都在这个方法里了
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                // p == head 说明当前节点虽然进到了阻塞队列，但是是阻塞队列的第一个，因为它的前驱是head
                // 注意，阻塞队列不包含head节点，head一般指的是占有锁的线程，head后面的才称为阻塞队列
                // 所以当前节点可以去试抢一下锁
                // 这里我们说一下，为什么可以去试试：
                // 首先，它是队头，这个是第一个条件，其次，当前的head有可能是刚刚初始化的node，
                // enq(node) 方法里面有提到，head是延时初始化的，而且new Node()的时候没有设置任何线程
                // 也就是说，当前的head不属于任何一个线程，所以作为队头，可以去试一试，
                // tryAcquire已经分析过了, 忘记了请往前看一下，就是简单用CAS试操作一下state
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                // 到这里，说明上面的if分支没有成功，要么当前node本来就不是队头，
                // 要么就是tryAcquire(arg)没有抢赢别人，继续往下看
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            // 什么时候 failed 会为 true???
            // tryAcquire() 方法抛异常的情况
            if (failed)
                cancelAcquire(node);
        }
    }
  
    /**
     * Checks and updates status for a node that failed to acquire.
     * Returns true if thread should block. This is the main signal
     * control in all acquire loops.  Requires that pred == node.prev
     *
     * @param pred node's predecessor holding status
     * @param node the node
     * @return {@code true} if thread should block
     */
    // 刚刚说过，会到这里就是没有抢到锁呗，这个方法说的是："当前线程没有抢到锁，是否需要挂起当前线程？"
    // 第一个参数是前驱节点，第二个参数才是代表当前线程的节点
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        // 前驱节点的 waitStatus == -1 ，说明前驱节点状态正常，当前线程需要挂起，直接可以返回true
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        
        // 前驱节点 waitStatus大于0 ，之前说过，大于0 说明前驱节点取消了排队。
        // 这里需要知道这点：进入阻塞队列排队的线程会被挂起，而唤醒的操作是由前驱节点完成的。
        // 所以下面这块代码说的是将当前节点的prev指向waitStatus<=0的节点，
        // 简单说，就是为了找个好爹，因为你还得依赖它来唤醒呢，如果前驱节点取消了排队，
        // 找前驱节点的前驱节点做爹，往前遍历总能找到一个好爹的
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            // 仔细想想，如果进入到这个分支意味着什么
            // 前驱节点的waitStatus不等于-1和1，那也就是只可能是0，-2，-3
            // 在我们前面的源码中，都没有看到有设置waitStatus的，所以每个新的node入队时，waitStatu都是0
            // 正常情况下，前驱节点是之前的 tail，那么它的 waitStatus 应该是 0
            // 用CAS将前驱节点的waitStatus设置为Node.SIGNAL(也就是-1)
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        // 这个方法返回 false，那么会再走一次 for 循序，
        //     然后再次进来此方法，此时会从第一个分支返回 true
        return false;
    }
  
    // private static boolean shouldParkAfterFailedAcquire(Node pred, Node node)
    // 这个方法结束根据返回值我们简单分析下：
    // 如果返回true, 说明前驱节点的waitStatus==-1，是正常情况，那么当前线程需要被挂起，等待以后被唤醒
    //		我们也说过，以后是被前驱节点唤醒，就等着前驱节点拿到锁，然后释放锁的时候叫你好了
    // 如果返回false, 说明当前不需要被挂起，为什么呢？往后看
  
    // 跳回到前面是这个方法
    // if (shouldParkAfterFailedAcquire(p, node) &&
    //                parkAndCheckInterrupt())
    //                interrupted = true;
    
    // 1. 如果shouldParkAfterFailedAcquire(p, node)返回true，
    // 那么需要执行parkAndCheckInterrupt():
  
    // 这个方法很简单，因为前面返回true，所以需要挂起线程，这个方法就是负责挂起线程的
    // 这里用了LockSupport.park(this)来挂起线程，然后就停在这里了，等待被唤醒=======
    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }
  
    // 2. 接下来说说如果shouldParkAfterFailedAcquire(p, node)返回false的情况
  
   // 仔细看shouldParkAfterFailedAcquire(p, node)，我们可以发现，其实第一次进来的时候，一般都不会返回true的，原因很简单，前驱节点的waitStatus=-1是依赖于后继节点设置的。也就是说，我都还没给前驱设置-1呢，怎么可能是true呢，但是要看到，这个方法是套在循环里的，所以第二次进来的时候状态就是-1了。
  
    // 解释下为什么shouldParkAfterFailedAcquire(p, node)返回false的时候不直接挂起线程：
    // => 是为了应对在经过这个方法后，node已经是head的直接后继节点了。剩下的读者自己想想吧。
}

模块 1：锁入口lock() + AQS 顶层模板方法acquire(1)

核心作用：公平锁争锁入口，复用 AQS 独占模式顶层模板方法，定义「尝试获取锁→失败入队→挂起等待」的通用流程。

// 争锁入口
final void lock() {
    acquire(1);
}

// 来自AQS的顶层模板方法，arg == 1
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        // 尝试获取失败，封装节点入队并挂起等待
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
          selfInterrupt();
    }
}

核心逻辑解析

1. lock()无额外逻辑，直接调用 AQS 的acquire(1)，参数 1 表示每次获取锁时同步状态state的增量 （重入锁时state累加 1）；
2. acquire(int arg)为短路执行逻辑 ，核心三步：
   • 先调用子类 FairSync 实现的tryAcquire(arg)非阻塞尝试获取锁，成功则直接返回，无需后续操作；
   • 若tryAcquire失败，执行addWaiter(Node.EXCLUSIVE)将当前线程封装为独占模式节点，加入 CLH 同步队列；
   • 再执行acquireQueued(入队节点, arg)，让入队线程自旋抢锁 / 挂起等待；
3. 若acquireQueued返回true，表示线程在等待过程中被中断，最终执行selfInterrupt()恢复线程的中断状态（Thread.interrupted()，中断标记会被清除）。

模块 2：公平式尝试获取锁tryAcquire(int acquires)

核心作用 ：FairSync 重写 AQS 的抽象方法，实现公平锁的非阻塞获取逻辑 ，是公平锁与非公平锁的核心差异点，返回boolean表示是否获取锁成功。

/**
 * Fair version of tryAcquire.  Don't grant access unless
 * recursive call or no waiters or is first.
 */
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    // state == 0 表示此时此刻无任何线程持有锁
    if (c == 0) {
        // 公平锁关键：先检查队列是否有等待线程，无等待才尝试CAS抢锁
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            // 标记当前线程为锁的独占持有者
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 锁重入：当前线程已是锁的持有者，直接累加state
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    // 锁被其他线程持有，或队列有等待线程，获取失败
    return false;
}

核心逻辑解析（acquires=1）

1. 先获取当前线程 和 AQS 的同步状态c （state是 volatile 变量，保证多线程可见性）；
2. 情况 1：c=0（无线程持有锁）
   • hasQueuedPredecessors()：公平锁核心校验，返回false表示CLH 队列无等待线程，保证「先来后到」；
   • compareAndSetState(0, 1)：CAS 原子修改同步状态，防止多线程同时抢锁；
   • 成功则标记当前线程为独占持有者，返回true（获取锁成功）；
3. 情况 2：当前线程是锁持有者（锁重入）
   • 计算新状态nextc = c + 1，处理 int 溢出（nextc<0抛异常）；
   • 直接setState(nextc)更新状态（无并发问题，因当前线程已持有锁），返回true（重入成功）；
4. 情况 3：以上均不满足
   • 说明锁被其他线程持有，或队列有等待线程，返回false（获取失败，进入入队流程）。

模块 3：封装节点入队addWaiter(Node mode) + enq(final Node node)

核心作用 ：tryAcquire失败后，将当前线程封装为 AQS 的Node节点，通过「快速入队 + 自旋入队」保证节点一定能加入 CLH 双向同步队列尾部 ，入队模式为Node.EXCLUSIVE（独占）。

3.1 子模块：快速入队addWaiter(Node mode)（非空队列优化）

/**
 * Creates and enqueues node for current thread and given mode.
 *
 * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
 * @return the new node
 */
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    // 队列非空时，尝试快速入队
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 队列为空或CAS入队失败，执行自旋入队
    enq(node);
    return node;
}

核心逻辑解析

1. 传入Node.EXCLUSIVE（独占模式），创建新节点并绑定当前线程和模式；
2. 获取队列尾节点pred，若pred!=null（队列非空）：
   • 建立双向连接：node.prev = pred，将当前节点的前驱指向原尾节点；
   • compareAndSetTail(pred, node)：CAS 原子将当前节点设为新的尾节点，解决多线程竞争入队问题；
   • CAS 成功则完成双向链表连接（pred.next = node），返回新节点（入队成功）；
3. 若pred==null（队列为空）或 CAS 失败（多线程同时抢入队），调用enq(node)执行兜底的自旋入队。

3.2 子模块：自旋入队enq(final Node node)（保证入队成功）

/**
 * Inserts node into queue, initializing if necessary. See picture above.
 * @param node the node to insert
 * @return node's predecessor
 */
private Node enq(final Node node) {
    for (;;) { // 无限自旋，直到入队成功
        Node t = tail;
        if (t == null) { // Must initialize：队列为空，初始化队列
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 队列非空，与addWaiter逻辑一致，CAS入队
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

核心逻辑解析

1. 无限for循环（自旋），保证节点最终能入队，解决多线程竞争入队问题；
2. 情况 1：t=tail==null（队列为空）
   • compareAndSetHead(new Node())：CAS 创建空的头节点 head（AQS 的 head 是「哨兵节点」，不绑定线程，代表当前持有锁的线程）；
   • 将tail = head，完成队列初始化，继续自旋（下次进入队列非空分支）；
3. 情况 2：t=tail!=null（队列已初始化）
   • 与addWaiter的非空队列逻辑一致，通过「前驱绑定 + CAS 设尾节点 + 后继绑定」完成入队；
   • CAS 成功则返回原尾节点，自旋结束（入队成功）。

模块 4：队列中自旋抢锁acquireQueued(final Node node, int arg)

核心作用 ：节点入队后，让线程在队列中自旋尝试获取锁 ，实现「非队头则挂起，是队头则抢锁」的核心逻辑，返回boolean表示线程等待过程中是否被中断。

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) { // 无限自旋，直到获取锁成功
            final Node p = node.predecessor(); // 获取当前节点的前驱节点
            // 前驱是head，说明是队列第一个等待节点，有抢锁资格
            if (p == head && tryAcquire(arg)) {
                setHead(node); // 将当前节点设为新的head（哨兵节点）
                p.next = null; // 断开原head，帮助GC回收
                failed = false;
                return interrupted;
            }
            // 非队头或抢锁失败，检查是否需要挂起，挂起后检测中断
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        // 仅当tryAcquire抛异常时，failed=true，取消节点排队资格
        if (failed)
            cancelAcquire(node);
    }
}

核心逻辑解析（arg=1）

1. 初始化标记：failed=true（标记获取锁是否失败，用于 finally 异常处理）、interrupted=false（标记线程是否被中断）；
2. 无限自旋，先获取当前节点的前驱节点 p （node.predecessor()会检查前驱是否为 null，避免空指针）；
3. 核心判断：p == head（当前节点是队列第一个等待节点）
   • 此时线程有「抢锁资格」，再次调用tryAcquire(1)尝试获取锁（可能锁已被释放）；
   • 若抢锁成功：
     • setHead(node)：将当前节点设为新的 head，解绑线程，成为新的哨兵节点；
     • p.next = null：断开原 head 的引用，帮助 GC 回收；
     • failed=false，返回interrupted（自旋结束，获取锁成功）；
4. 非队头或抢锁失败
   • 先执行shouldParkAfterFailedAcquire(p, node)：检查当前线程是否需要被挂起；
   • 若返回true，执行parkAndCheckInterrupt()：挂起线程，唤醒后检查是否被中断，若中断则置interrupted=true；
5. finally 异常处理
   • 仅当tryAcquire抛出异常时，failed保持true，调用cancelAcquire(node)取消当前节点的排队资格（从队列中移除），避免节点滞留。

模块 5：检查是否挂起shouldParkAfterFailedAcquire(Node pred, Node node)

核心作用 ：为acquireQueued提供判断依据 ------当前线程抢锁失败后，是否需要被挂起 ，核心是维护前驱节点的waitStatus状态，保证后续能被前驱节点唤醒（AQS 唤醒规则：前驱节点释放锁时唤醒后继节点）。

/**
 * Checks and updates status for a node that failed to acquire.
 * Returns true if thread should block. This is the main signal
 * control in all acquire loops.  Requires that pred == node.prev
 *
 * @param pred node's predecessor holding status
 * @param node the node
 * @return {@code true} if thread should block
 */
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    // 前驱节点状态为SIGNAL，当前线程可安全挂起
    if (ws == Node.SIGNAL)
        return true;
    // 前驱节点状态>0（仅CANCELLED=1），表示前驱已取消排队，向前寻找有效前驱
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 前驱状态为0或PROPAGATE，CAS将其设为SIGNAL（标记需要唤醒后继）
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    // 第一次调用必返回false，需重新自旋
    return false;
}

核心逻辑解析（参数：pred = 前驱节点，node = 当前节点）

1. 先获取前驱节点的状态ws = pred.waitStatus（AQS 节点核心状态：SIGNAL=-1「需唤醒后继」、CANCELLED=1「取消排队」、0「默认初始状态」、PROPAGATE=-3「共享模式用」）；
2. 情况 1：ws == Node.SIGNAL（-1）
   • 前驱节点已标记「会唤醒后继节点」，当前线程可安全挂起，返回true；
3. 情况 2：ws > 0（仅CANCELLED=1）
   • 前驱节点已取消排队，向前遍历队列 ，跳过所有取消节点，将当前节点的prev指向第一个有效前驱（ws<=0）；
   • 重连双向链表（pred.next = node），返回false（需重新自旋判断）；
4. 情况 3：ws == 0 或 ws == PROPAGATE
   • 新节点入队时waitStatus默认是 0，通过compareAndSetWaitStatusCAS 将前驱状态设为SIGNAL；
   • 返回false（第一次调用必走此分支，需重新自旋）；

关键特性：第一次调用一定返回false，第二次自旋后调用会返回true------ 先标记前驱为SIGNAL，再挂起线程，避免「唤醒丢失」。

模块 6：挂起线程并检查中断parkAndCheckInterrupt()

核心作用 ：当shouldParkAfterFailedAcquire返回true时执行，是实际挂起线程的方法，同时检测线程挂起过程中是否被中断，并清除中断标记。

// 挂起当前线程，唤醒后检查中断状态
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this); // 挂起线程，进入阻塞状态，等待被unpark唤醒
    return Thread.interrupted(); // 返回中断状态并清除中断标记
}

核心逻辑解析

1. LockSupport.park(this)：挂起当前线程，线程进入WAITING 阻塞状态 ，执行到此行后停止运行，直到被其他线程调用LockSupport.unpark(this)唤醒（通常是前驱节点释放锁时）；
2. 线程被唤醒后，执行Thread.interrupted()：
   • 返回当前线程的中断状态 （true= 被中断，false= 正常唤醒）；
   • 清除线程的中断标记 （重点：此方法是静态方法，会重置中断状态为false）；
3. 将中断状态返回给acquireQueued，由其记录到interrupted变量中，最终作为acquireQueued的返回值。

公平锁完整争锁流程（代码执行顺序）

结合以上 6 个模块，从线程调用lock()开始，完整的公平锁获取流程如下：

1. 线程调用FairSync.lock() → 触发 AQSacquire(1)；
2. 执行tryAcquire(1)公平尝试获取锁：成功则直接返回，失败则进入入队流程；
3. 执行addWaiter(Node.EXCLUSIVE)快速入队：队列非空且 CAS 成功则直接入队，否则执行enq(node)自旋入队，直到节点加入队列尾部；
4. 执行acquireQueued(入队节点, 1)自旋抢锁：a. 若前驱是 head，调用tryAcquire(1)抢锁，成功则设为新 head，获取锁并返回；b. 若抢锁失败，执行shouldParkAfterFailedAcquire：第一次返回false，重新自旋；第二次返回true，执行parkAndCheckInterrupt()；
5. 执行parkAndCheckInterrupt()，线程被挂起，等待前驱节点释放锁后唤醒；
6. 线程被唤醒后，继续自旋（回到步骤 4a），重复「抢锁→检查挂起」逻辑，直到成功获取锁；
7. 若线程挂起过程中被中断，acquireQueued返回true，最终执行selfInterrupt()恢复线程中断状态。

2.解锁操作

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

public final boolean release(int arg) {
    // 往后看吧
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

// 回到ReentrantLock看tryRelease方法
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 是否完全释放锁
    boolean free = false;
    // 其实就是重入的问题，如果c==0，也就是说没有嵌套锁了，可以释放了，否则还不能释放掉
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

/**
 * Wakes up node's successor, if one exists.
 *
 * @param node the node
 */
// 唤醒后继节点
// 从上面调用处知道，参数node是head头结点
private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    int ws = node.waitStatus;
    // 如果head节点当前waitStatus<0, 将其修改为0
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    /*
     * Thread to unpark is held in successor, which is normally
     * just the next node.  But if cancelled or apparently null,
     * traverse backwards from tail to find the actual
     * non-cancelled successor.
     */
    // 下面的代码就是唤醒后继节点，但是有可能后继节点取消了等待（waitStatus==1）
    // 从队尾往前找，找到waitStatus<=0的所有节点中排在最前面的
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 从后往前找，仔细看代码，不必担心中间有节点取消(waitStatus==1)的情况
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        // 唤醒线程
        LockSupport.unpark(s.thread);
}

模块 1：解锁入口unlock()

核心作用 ：ReentrantLock 对外暴露的解锁公共方法，无额外业务逻辑，直接调用内部同步器sync的release(1)方法，是解锁流程的顶层入口 （sync为多态，适配 FairSync 公平锁 / NonfairSync 非公平锁，解锁逻辑统一）。

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

核心逻辑解析

1. 入参1：与加锁时acquire(1)对应，表示每次解锁时同步状态state的减量，匹配重入锁的 "加 1 减 1" 规则（重入 n 次需解锁 n 次）；
2. 调用链路：通过内部的Sync对象（AQS 子类）调用 AQS 的release(int arg)顶层模板方法，将解锁逻辑委托给 AQS 框架，体现 AQS模板方法设计模式；
3. 无返回值：解锁失败（如非锁持有者调用）会直接抛出异常，而非返回布尔值。

模块 2：AQS 顶层解锁模板方法release(int arg)

核心作用 ：AQS 提供的独占模式解锁顶层模板方法，定义了**"尝试释放锁→成功则唤醒后继节点"** 的通用解锁流程，子类仅需实现tryRelease(arg)的具体释放逻辑，其余通用逻辑（如唤醒等待线程）由 AQS 统一实现。

public final boolean release(int arg) {
    // 尝试释放锁，成功则执行后续唤醒逻辑
    if (tryRelease(arg)) {
        Node h = head;
        // 头节点非空且状态非0，说明队列中有等待的有效节点，需要唤醒
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

核心逻辑解析（arg=1，独占模式专属）

1. 短路执行核心 ：先调用子类（ReentrantLock）实现的tryRelease(arg)尝试释放锁，只有释放成功（返回 true），才会执行后续的「获取头节点 + 唤醒后继」逻辑；若释放失败，直接返回 false，无任何后续操作；
2. 头节点判空 ：h = head获取 CLH 队列头节点，若h == null表示队列为空（无线程等待锁），无需唤醒；
3. 头节点状态校验 ：h.waitStatus != 0是唤醒的关键条件 ------AQS 节点默认waitStatus=0，若头节点状态非 0，说明其后续存在需要被唤醒的等待节点 （如waitStatus=-1（SIGNAL），表示头节点有责任唤醒后继）；若状态为 0，说明无等待节点，无需唤醒；
4. 返回值含义 ：true表示锁释放成功（重入锁为 "完全释放"，即state=0），false表示释放未完成（如重入锁仅释放了一次，state>0）。

模块 3：ReentrantLock 独占式释放核心tryRelease(int releases)

核心作用 ：ReentrantLock 重写 AQS 的tryRelease方法，实现独占锁的具体释放逻辑 ，是解锁流程的核心实现 ，严格遵循独占模式规则：仅锁持有者可释放、重入锁需完全释放（state=0）才真正释放锁，返回boolean表示是否完全释放锁。

protected final boolean tryRelease(int releases) {
    // 计算释放后的同步状态：当前state - 释放量（releases=1）
    int c = getState() - releases;
    // 独占模式核心校验：释放锁的线程必须是锁的独占持有者
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 标记是否完全释放锁（state=0）
    boolean free = false;
    // 仅当state减至0时，才表示真正释放锁（解决重入锁释放问题）
    if (c == 0) {
        free = true;
        // 清空锁的独占持有者，标记为无锁状态
        setExclusiveOwnerThread(null);
    }
    // 更新同步状态（即使未完全释放，也需更新state，如重入锁多次释放）
    setState(c);
    // 返回是否完全释放锁，决定上层release是否执行唤醒逻辑
    return free;
}

核心逻辑解析（releases=1，独占模式关键特性体现）

1. 计算新同步状态 ：c = getState() - releases，基于当前state做减量，匹配加锁时的增量规则，保证重入锁的 "加多少次减多少次"；
2. 严格的持有者校验 ：这是独占模式的核心限制 ------ 通过getExclusiveOwnerThread()获取当前锁持有者，若释放线程与持有者不一致，直接抛出IllegalMonitorStateException，避免非持有者释放锁，保证锁的排他性；
3. 区分 "部分释放" 和 "完全释放" ：
   • 定义free标记，仅当c == 0时置为true，表示锁被完全释放（无重入嵌套，真正回到无锁状态）；
   • 若c > 0（重入锁仅释放了一次，还有嵌套），free为false，表示部分释放 ，仅更新state，不清空持有者；
4. 完全释放的关键操作 ：当c == 0时，调用setExclusiveOwnerThread(null)清空锁的独占持有者，这是无锁状态的核心标记；
5. 更新同步状态 ：无论是否完全释放，最终都会调用setState(c)更新state------ 因当前线程是锁持有者，此操作无并发问题，无需 CAS，直接赋值即可；
6. 返回值的核心作用 ：返回free（是否完全释放）给上层release方法，决定是否执行后续的唤醒等待线程逻辑 ------仅完全释放锁时，才会唤醒队列中的等待线程，避免重入锁中途释放时的无效唤醒。

模块 4：AQS 唤醒后继节点unparkSuccessor(Node node)

核心作用 ：当锁被完全释放后，AQS 调用此方法唤醒 CLH 队列中头节点的有效后继等待线程 ，是独占模式解锁的收尾操作 ，保证等待队列中的线程能继续竞争锁，实现 "释放 - 唤醒" 的同步机制（参数node为 CLH 队列的头节点head）。

/**
 * Wakes up node's successor, if one exists.
 *
 * @param node the node the node（此处为head头结点）
 */
private void unparkSuccessor(Node node) {
    // 获取头节点的当前等待状态
    int ws = node.waitStatus;
    // 若头节点状态<0（通常为SIGNAL=-1），将其CAS置为0，清除唤醒标记
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    // 找到头节点的直接后继节点，作为候选唤醒节点
    Node s = node.next;
    // 若后继节点为null，或后继节点已取消等待（waitStatus>0，仅CANCELLED=1），则寻找有效后继
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 从队尾tail向前遍历，找到第一个waitStatus<=0的有效等待节点
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    // 若找到有效后继节点，唤醒其绑定的线程
    if (s != null)
        LockSupport.unpark(s.thread);
}

核心逻辑解析（参数为 head 头节点，独占模式唤醒规则）

1. 清除头节点的唤醒标记 ：
   • 头节点的waitStatus<0通常为SIGNAL=-1（表示头节点有责任唤醒后继节点），这是之前等待节点通过shouldParkAfterFailedAcquire设置的；
   • 通过compareAndSetWaitStatus将头节点状态 CAS 置为 0，清除唤醒标记，表示头节点的 "唤醒责任" 已完成，恢复节点默认状态；
2. 先尝试获取直接后继 ：s = node.next获取头节点的直接后继节点，这是最理想的唤醒对象（CLH 队列按 "先来后到" 排队，直接后继是第一个等待线程）；
3. 处理无效后继节点 ：若直接后继s == null（队列无后继）或s.waitStatus > 0（后继节点因超时 / 中断取消等待 ，状态为CANCELLED=1），则需要从队尾向前遍历 寻找有效后继：
   • 遍历方向：从 tail 到 head （而非 head 到 tail），原因是 CLH 队列是双向链表，节点的next引用可能因取消等待被置为 null，而prev引用始终稳定，能保证遍历到所有节点；
   • 有效节点条件：waitStatus <= 0（包括0默认状态、SIGNAL=-1等待状态、PROPAGATE=-3共享模式状态，均为未取消的有效节点）；
   • 遍历终止条件：t != null && t != node（遍历至头节点为止，不包含头节点）；
4. 唤醒有效后继线程 ：若找到有效后继节点s，调用LockSupport.unpark(s.thread)唤醒其绑定的线程 ------ 被唤醒的线程会回到之前的acquireQueued自旋逻辑，重新尝试调用tryAcquire获取锁；
5. 独占模式的唤醒特性 ：此方法仅唤醒一个有效后继节点，而非多个，保证同一时刻只有一个线程参与锁竞争，符合 ReentrantLock「独占锁」的核心语义（与共享模式的 "链式唤醒" 形成鲜明对比）。

完整解锁流程（按代码执行顺序）

结合以上 4 个模块，ReentrantLock（公平锁 / 非公平锁）的完整解锁执行步骤如下（贴合独占模式，衔接之前的加锁流程）：

1. 线程调用ReentrantLock.unlock()，触发内部sync.release(1)；
2. 执行 AQS 的release(1)，先调用 ReentrantLock 的tryRelease(1)尝试释放锁；
3. tryRelease(1)执行逻辑：a. 计算c = getState() - 1，校验当前线程是否为锁持有者，非持有者直接抛IllegalMonitorStateException；b. 若c == 0（完全释放，无重入嵌套），置free=true，清空锁持有者，更新state=0，返回true；c. 若c > 0（部分释放，还有重入），置free=false，仅更新state=c，返回false；
4. 若tryRelease返回false（部分释放），release直接返回false，解锁流程结束，无唤醒操作；
5. 若tryRelease返回true（完全释放），release获取头节点head，若head != null && head.waitStatus != 0，调用unparkSuccessor(head)；
6. unparkSuccessor(head)执行逻辑：a. 清除头节点的唤醒标记（waitStatus置 0）；b. 先找头节点直接后继，若无效则从队尾向前遍历，找到第一个有效等待节点；c. 调用LockSupport.unpark唤醒有效后继的线程，被唤醒的线程回到acquireQueued自旋抢锁；
7. release方法返回true，整个解锁流程完成。

四、非公平锁

核心前提：非公平锁与公平锁的关键差异

公平锁获取锁前，会先调用 hasQueuedPredecessors() 检查同步队列是否有前驱等待线程 ，若有则必须入队，无则才尝试抢锁；非公平锁直接跳过该校验 ，无论队列是否有等待线程，新线程都会先直接尝试抢锁，这是 "非公平" 的核心体现。

非公平锁获取锁的完整流程（从调用 lock() 开始）

阶段 1：首次插队 ------ 直接 CAS 抢占锁（无任何前置校验）

调用非公平锁的 lock() 方法后，第一步直接执行 CAS 原子操作 ，尝试将 AQS 的state变量从0（空闲）修改为1（占用）：

• 底层核心代码：compareAndSetState(0, 1)
• 执行结果 1（CAS 成功）：当前线程直接获取锁 ，并将 AQS 的exclusiveOwnerThread（独占锁持有线程）设为当前线程，整个抢锁流程结束，只有当state等于0的时候才会成功；
• 执行结果 2（CAS 失败）：说明锁已被占用（state≥1），进入阶段 2：可重入判断。

阶段 2：可重入校验 ------ 当前线程是否已持有锁

CAS 抢锁失败后，不会直接入队等待，而是先做可重入判断 （ReentrantLock 的核心特性），通过getState()获取当前state值，同时判断exclusiveOwnerThread是否为当前线程：

• 情况 1（是当前线程持有锁）：说明是同一线程重入 ，直接将state值自增 1 （如state从 1 变为 2，记录重入次数），无需等待，直接获取锁，流程结束；
• 情况 2（不是当前线程持有锁）：说明锁被其他线程占用，进入阶段 3：入队自旋等待。

阶段 3：入队等待 ------ 封装节点入同步队列，自旋重试抢锁

若既不是首次 CAS 抢锁成功，也不是可重入场景，当前线程会进入 AQS 的常规同步队列流程 ，核心是「封装节点入队 + 自旋重试 + 阻塞唤醒」，且自旋过程中仍有非公平抢锁机会，具体步骤：

1. 封装线程为 Node 节点 ：调用addWaiter(Node.EXCLUSIVE)，将当前线程封装为独占式 Node 节点 （非公平锁为独占锁），并加入 AQS 同步队列的队尾（CAS 入队，保证原子性）；
2. 自旋抢锁（核心） ：调用acquireQueued(node, arg)进入自旋循环，每次自旋都会尝试抢锁 ，且仍保留非公平特性：
   • 第一步：判断当前节点的前驱节点是否为队列头节点（只有头节点的后继节点有抢锁资格）；
   • 第二步：若满足前驱是头节点，再次尝试 CAS 抢锁 （将state从 0 改为 1）；
   • 第三步：CAS 成功→获取锁，将当前节点设为头节点，流程结束；CAS 失败→判断是否需要阻塞当前线程；
3. 线程阻塞 ：若自旋抢锁失败，通过LockSupport.park(this)将当前线程从「运行态」转为「阻塞态」，停止自旋，等待被唤醒；
4. 唤醒后重试 ：当持有锁的线程释放锁时，会调用unpark()唤醒同步队列中头节点的后继节点 ，被唤醒的线程会重新进入自旋循环，再次尝试 CAS 抢锁，直到获取锁为止。

关键补充：自旋过程中的 "非公平性"

即使线程已进入同步队列，在前驱节点释放锁、当前节点被唤醒后 ，新的请求线程依然可以和被唤醒的线程同时竞争锁------ 新线程可能先 CAS 抢锁成功，被唤醒的线程会再次进入阻塞，这是非公平锁 "插队" 特性的延伸，也是其效率高的重要原因。