AQS源码（三）

手把手教你阅读AQS源码（三）

ReentrantLock的公平锁和非公平锁的释放锁的逻辑从源码层面上来看是相同的，我们跟进源码看下具体流程。
还是之前的调试Demo

public class ReentrantLockDemo {
    public static void main(String[] args) {
        final ReentrantLock lock = new ReentrantLock(true);
        try {
            lock.lock();
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } finally {
        // 一般使锁的时候，必须将释放锁的代码放到finally块中，避免某个线程一直占用锁资源
            lock.unlock();
        }
    }
}

Debug跟进去走到ReentrantLock的unlock()

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

调用了sync内部类的release()，Sync对于父类AQS的release()并未重写，走到了AQS中

AQS:
public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

tryRelease(arg)也是一个模板方法，由子类来实现

AQS:
protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }

最终走到ReentrantLock的tryRelease(1)

protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

这块就是ReentrantLock的释放锁逻辑：
在释放锁的时候，先给state值减1，并且当前线程必须是持有锁的线程（你不能把别人的锁释放了），如果此时当前的状态为0，表示释放锁ok了，再把持有锁的线程置空。如果此时当前状态还大于0，表示是重入锁还没有完全释放。
再回过头看下AQS中方法的调用处:

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

如果当前线程释放锁返回true，那么就会走if的逻辑。既然释放锁成功了，那么还需要做什么？看下方法的名称unparkSuccessor()，那么就要去唤醒后继节点。

private void unparkSuccessor(Node node) {
        int ws = node.waitStatus;
        // ①
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);
        // ②
        Node s = node.next;
        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);
    }

node是头节点。①这里就修改一下头结点的状态为0,
②Node s表示头结点的后继节点，首先如果s是正常等待状态就直接唤醒该节点（②的这个if不成立，走③直接unpark当前节点的线程）
如果s的等待状态异常，那么会从队列的尾部开始遍历，找到离头结点最近的一个正常等待节点进行唤醒。
【这里解释下为什么从尾部开始遍历】：
首先线程Node入队列的时候，先把自己的prev节点连到队列的尾节点，然后CAS设置自己为尾节点成功后，才将原来的尾结点的next指针指向自己，如果在这一步的时候，当前节点要被唤醒的话，由于next指针还没有指向当前节点，因此从头向尾遍历可能找不到当前节点，从尾部开始遍历就不存在这个问题了。