AQS 详解之独占锁

本文以ReentrantLock的非公平锁图解 AQS 独占锁加解锁过程。

前置知识了解

static final class Node {
    /** 标记为共享节点 */
    static final Node SHARED = new Node();
    /** 标记为独占节点 */
    static final Node EXCLUSIVE = null;
    /** 等待状态值，表示被取消 */
    static final int CANCELLED =  1;
    /** 等待状态值，表示节点在释放或者取消的时候，需要唤醒下一个节点 */
    static final int SIGNAL    = -1;
    /** 等待状态值，表示线程有条件等待 */
    static final int CONDITION = -2;
    /** 等待状态值，表示共享锁唤醒了一个节点需要向后传播 */
    static final int PROPAGATE = -3;
    /** 等待状态 */
    volatile int waitStatus;
    /** 前驱节点 */
    volatile Node prev;
    /** 后置节点 */
    volatile Node next;
    /** 节点关联的线程 */
    volatile Thread thread;
}

独占锁加锁

非公平锁加锁的时候代码：

final void lock() {
    // 先抢占一次，看看有没有人占有锁，没有自己就拿下，将当前线程设为自己
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // 抢占失败，那么就去获取独占锁
        acquire(1);
}

重点看acquire(1)：

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

tryAcquire方法是用来给子类重写的，如果获取成功返回true，则万事大吉，否则进入队列。
先看tryAcquire方法。

protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    // 获取 AQS 状态
    int c = getState();
    // 如果等于0则表示无人持有锁，可以去获取锁
    if (c == 0) {
        // 如果获取锁成功，则将 AQS 线程设置为当前线程，返回 true
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 否则看 AQS 线程是否为当前线程，如果是的话说明当前线程在重入，返回 true
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    // 获取非公平锁失败
    return false;
}

接下来看看进入等待队列的方法，入参是Node.``EXCLUSIVE，是一个排它锁。

private Node addWaiter(Node mode) {
    // 根据当前线程创建出一个节点
    Node node = new Node(Thread.currentThread(), mode);
    // 获取队列的尾节点
    Node pred = tail;
    // 如果尾节点存在，那么将尾节点作为当前节点的前置节点
    if (pred != null) {
        node.prev = pred;
        // 通过 cas 将当前节点作为队列的尾节点，这就是成功入队了
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 如果不存在尾节点，则进入 enq(node)
    enq(node);
    return node;
}
/**
 * 将节点插入队列，如果有必要的话会初始化队列
 */
private Node enq(final Node node) {
    // 自旋操作
    for (;;) {
        // 获取尾节点
        Node t = tail;
        // 如果尾节点为 null，则说明需要初始化队列，初始化完成之后进行下一次自旋，下一次就不会进入这里了
        if (t == null) {
            // 生成一个 Node 对象，作为头节点，然后将尾节点也指向头节点，此时 tail == head = new Node()
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 如果尾节点不是 null，说明此时队列已经存在，此时再将新的节点插入到队列尾部
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

入队之后的线程该做什么呢，接下来就要看acquireQueued方法做了什么了，

final boolean acquireQueued(final Node node, int arg) {
    // 标记是否失败
    boolean failed = true;
    try {
        // 标记是否中断
        boolean interrupted = false;
        for (;;) {
            // 拿到当前节点的前置节点
            final Node p = node.predecessor();
            /* 
             * 如果前置节点是头节点，说明自己排在第一个，可以再次去获取一次锁，
             * 如果这一次获取锁成功了，那么将当前节点作为新的头节点，旧的头节点的后置节点置为 null
            */
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                // 此时获取成功了，那么将失败标记置为 false
                failed = false;
                return interrupted;
            }
            /*
             * 如果前置节点不是头节点，或者前置节点是头节点但是获取锁失败了，此时就要进入这里面了
             * 判断在获取锁失败之后，是不是需要 park，如果需要则去 park
             */
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        // 如果失败，则取消获取
        if (failed)
            cancelAcquire(node);
    }
}

看看shouldParkAfterFailedAcquire方法。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) 
    // 前置节点的等待状态
    int ws = pred.waitStatus;
	// 如果前置节点的等待状态是 SIGNAL，即-1，则表示当前节点如果睡着（park）了，前面的人忙完了会叫醒自己，可以放心的睡了
    if (ws == Node.SIGNAL)
        return true;
    if (ws > 0) {
        /*
         * 如果等待状态大于0，说明前置节点的状态是 CANCELLED（1），被取消了，是不可信任的，自己睡着了的话没人叫醒自己
         * 所以只能去找前置节点的前置节点，直到有一个节点的等待状态不是 CANCELLED 的，然后将自己的前置节点置为找到的能信任的节点
         */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * 进入这里的条件是等待状态为0或者-3（PROPAGATE）
         * 此时需要将前置节点的等待状态设为 SIGNAL，并且再次自旋一次，这样才能保证有人能唤醒自己
         * 下一次进入这个方法的额时候，就会从 ws == Node.SIGNAL 返回了
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
	// 如果返回了false，说明 acquireQueued 方法会继续执行自旋操作，会再次进入 shouldParkAfterFailedAcquire 方法
    return false;
}

parkAndCheckInterrupt的方法就很简单了

private final boolean parkAndCheckInterrupt() {
    // park，线程被阻塞在这里了
    LockSupport.park(this);
    // 在唤醒后返回中断状态
    return Thread.interrupted();
}

注意到，在acquireQueued中的finally代码块里，有一个cancelAcquire取消获取锁的方法，什么情况下会进入这里面呢。
在try里面是一个死循环，只有一个地方会return，但是return之前，failed置为false了，此时是不会进入cancelAcquire里面的。所以进入cancelAcquire方法的原因只有–发生了异常或者当前线程被中断了，这两种情况都是不正常的，所以要取消获取锁。接下来看看cancelAcquire方法。

private void cancelAcquire(Node node) {
    // 如果节点不存在，则不需要处理了
    if (node == null)
        return;
    // 将节点所持有的线程引用置为 null
    node.thread = null;
    /*
     * 如果前置节点已经被取消了，则跳过当前前置节点，将当前节点的前置节点设置为自己的前置节点
     * 即，如果本来是 A <-- B <-- Current,如果 B 被取消了，那么现在就是 A <-- Current
     */
    Node pred = node.prev;
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;

    // 前置节点的后置节点，其实就是当前节点，这里是为了用 ACS 移除，所以这么做
    Node predNext = pred.next;

    // 将当前节点的等待状态设置为 1 CANCELLED
    node.waitStatus = Node.CANCELLED;

    // 如果当前节点是尾节点，那么将前置节点设置为队列的尾节点，然后将当前节点移除
    if (node == tail && compareAndSetTail(node, pred)) {
        compareAndSetNext(pred, predNext, null);
    } else {
        // 如果自己的前置节点答应唤醒后置节点，那么就将自己的后置节点交给前置节点唤醒，否则自己唤醒后置节点，要有责任心
        int ws;
        // 如果当前节点的前置节点不是头节点
        if (pred != head &&
            // 并且前置节点的等待状态不是信号唤醒，或者前置节点的等待状态是小于0且成功将其等待状态设置为了 SIGNAL
            ((ws = pred.waitStatus) == Node.SIGNAL ||
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            // 并且前置节点的线程不是 null
            pred.thread != null) {
            //如果后置节点不为 null并且没有被取消，那么将前置节点的后置节点设置为自己的后置节点，自己全身而退
            Node next = node.next;
            if (next != null && next.waitStatus <= 0)
                compareAndSetNext(pred, predNext, next);
        } else {
            // 直接唤醒后置节点
            unparkSuccessor(node);
        }
		// 让自己无牵无挂
        node.next = node; // help GC
    }
}

独占锁解锁

独占锁解锁过程看 AQS 的release方法。

public final boolean release(int arg) {
    // 尝试释放锁
    if (tryRelease(arg)) {
        Node h = head;
        // 如果头节点不是 null（说明存在队列），并且头节点的状态不是等于0，那么唤醒后置节点
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    // 释放锁失败
    return false;
}

看看tryRelease方法，该方法公平锁和非公平锁是一样的。

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    // 如果 AQS 线程不是当前线程，那么抛出异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 释放成功结果
    boolean free = false;
    /*
     * 如果等于0，那么就是释放成功，设置 AQS 持有线程为 null
     * 如果不等于0，那就是大于0，此时说明锁被重入了，需要多次释放才行
     */
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

在取消获取锁的时候有一个unparkSuccessor方法没有分析，在这里进行补充。

private void unparkSuccessor(Node node) {
    // 当前节点的等待状态如果小于0，则设置为0，当前节点是要取消的，那么等待状态是1，则不需要进行归0操作
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    // 当前节点的后续节点
    Node s = node.next;
    /*
     * 如果后置节点为 null或者已经被取消了，那么就从队列的尾节点开始找
     * 找到 waitStatus <= 0 的节点来唤醒
     */
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        // 唤醒
        LockSupport.unpark(s.thread);
}

流程图