深入并发AQS三

深入并发AQS二主要关注锁的申请，这里记录下ReentrantLock对于锁的释放过程。

之前提过当线程释放锁时，会查看ＣＬＨ队列中是否有线程正在等待，原则上会先释放header结点后的线程结点。

对于ReentrantLock,当前线程释放锁时有两种情况：

　1.当前CLH队列无阻塞线程结点

　2.当前ＣＬＨ队列有阻塞线程结点

　　对于这种情况需要唤醒队列中线程，分以下几个步骤：
   第一步：
   先执行ReentranLock的tryRelease方法，它会将当前线程状态置减１。如果当前state值为０，则将exclusiveOwnerThread置为ＮＵＬＬ。在这里ReentranLock的tryRelease方法可以不加锁，因为释放操作只能由当前拥有这个锁的线程去做。
  第二步：
   尝试唤醒队列中线程。

对于锁释放操作客户端调用ReentrantLock的unlock时会调用sync.release(1)，然后sync会调用父类ＡＱＳ的release(int arg)方法，这个调用过程如下：
  reentrantLock.unlock() => sync.release(1) => AQS的release(int arg)。

接下去看下具体细节，这里因为最终调用的是AQS方法，因此先理解AQS的release方法，代码如下：

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)方法，这个tryRelease(arg)方法在子类NonFairSync类实现。
它的作用就是上述提到的将锁持久状态state减１。如果state减后为０，这时将exclusiveOwnerThread置为ＮＵＬＬ。
代码如下：

 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;
 }

这里tryRelease没有用到锁。

接着如果tryRelease返回true表明已经完全释放了锁的时候，返回到AQS的release方法：

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

这时会进入if (tryRelease(arg))内部的释放队列中结点的操作。这里先取出header结点。然后如果header结点不为空并且其waitStatus不为０（表明至少有线程在队列中出现），这时调用unparkSuccessor方法，进行释放线程结点操作。
unparkSuccessor方法代码如下：
 

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;
        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.
         */
        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);
    }

这里会先将header结点先置为０（如果当前header没有被取消或者已经是０的状态）。
然后从队列中找出header的下一个结点，有的话执行LockSupport.unpark(s.thread);释放锁。

否则会尝试从tail开始往前找到一个没被取消，不是header结点且非null的结点，将它进行释放。

这样锁释放部分流程已经解析完成。