ReentrantLock解锁源码浅析

公平锁解锁
解锁可以分解成两个步骤：

• 解锁
• 唤醒等待线程

// 解锁操作
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;
}

• 解锁

// 下面逻辑不存在并发问题，因为当前线程已经获取了锁
protected final boolean tryRelease(int releases) {
    // 计算解锁后的state
    int c = getState() - releases;
    // 如果解锁线程和持有锁的线程不是一个线程，那么直接抛异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 如果c解锁后等于0，那么说明这个线程完全不持有锁了
    if (c == 0) {
        // 解锁成功
        free = true;
        // 把持有锁的线程引用置为null
        setExclusiveOwnerThread(null);
    }
    // 设置解锁后state值。
    // 这个解锁有可能是在多次lock后执行unlock
    // 这样的话，持有锁的线程还是当前线程，只不过state减少
    setState(c);
    // 返回解锁结果
    return free;
}

示例：

// 创建一个公平锁
ReentrantLock lock = new ReentrantLock(true);
try{
    // 竞争锁
    lock.lock();
    // 执行业务逻辑
    System.out.println("hello world");
}finally{
    // 解锁
    // state=0，并且setExclusiveOwnerThread(null)
    lock.unlock();
}

// 创建一个公平锁
ReentrantLock lock = new ReentrantLock(true);
try{
    // 竞争锁
    lock.lock();
    // 执行业务逻辑
    System.out.println("hello world");
    try{
        // 锁重入
        lock.lock();
        // 执行业务逻辑
        System.out.println("再次获取锁");
    }finally{
        // 第一次解锁。
        // state=state-1
        lock.unlock();
    }
}finally{
    // 再次解锁。
    // state=0, setExclusiveOwnerThread(null)
    lock.unlock();
}

• 唤醒等待线程

private void unparkSuccessor(Node node) {
    // 获取头节点状态
    int ws = node.waitStatus;
    // 如果head节点状态小于0，
    if (ws < 0)
        // 把头节点状态设置为0
        node.compareAndSetWaitStatus(ws, 0);
    // 获取头节点下一个节点
    Node s = node.next;
    // 如果下一个节点为空，或者下一个节点状态是“取消”状态
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 通过从后向前遍历，寻找最靠近头节点的状态小于等于0的节点
        for (Node p = tail; p != node && p != null; p = p.prev)
            if (p.waitStatus <= 0)
                s = p;
    }
    if (s != null)
        // 如果存在靠近头节点，并且状态小于等于0的节点
        // 那么直接唤醒该节点
        LockSupport.unpark(s.thread);
}

在上面的解锁过程中，一直没有看到任何处理head节点的代码。理论上来说，head节点在解锁后就应该没有任何变量引用它，那么head节点是在什么时候被处理掉的呢？
其实答案在下面的代码中：

final boolean acquireQueued(final Node node, int arg) {
    // 默认线程未被打断
    boolean interrupted = false;
    try {
        // 开启自旋
        for (;;) {
            // 获取当前节点的前一个节点
            final Node p = node.predecessor();
            // 如果前一个节点是head节点，那么就尝试竞争锁
            if (p == head && tryAcquire(arg)) {
                // 竞争锁成功，把当前节点设置为head节点
                setHead(node);
                // 把前一个节点和当前节点断开
                // 因为当前节点已经设置为head节点了，之前的head就可以GC了
                p.next = null; // help GC
                // 返回是否当前线程被打断。
                // 这个返回结果的作用会被用在lockInterruptibly()这个方法上。
                // lock()方法可忽略。
                return interrupted;
            }
            // 判断当前节点是否应该阻塞。
            if (shouldParkAfterFailedAcquire(p, node))
                // 下面这个代码可以翻译成：
                // if(parkAndCheckInterrupt()){
                //     interrupted = true;
                // }
                interrupted |= parkAndCheckInterrupt();
        }
    } catch (Throwable t) {
        // 抛出任何异常，都直接取消当前节点正在竞争锁的操作
        // 如果在等待队列中，就从等待队列中移除。
        // 如果当前线程已经抢占到锁了，那么就解锁。
        cancelAcquire(node);
        // 如果当前线程已经被中断
        if (interrupted)
            // 重新设置中断信号
            selfInterrupt();
        // 抛出当前异常
        throw t;
    }
}

当等待队列中的节点竞争到锁后，会把自己变成head节点，之前的head节点就断开所有的引用，直至被GC。