AbstractQueuedSynchronizer(队列同步器，AQS)源码剖析（三）

1.1release

接下来我们在看看如何释放锁，源码如下

public final boolean release(int arg) {//释放锁方法（独占模式） if (tryRelease(arg)) {//尝试释放锁 Node h = head; if (h != null && h.waitStatus != 0)//如果head结点不为空并且等待状态不等于0就去唤醒后继结点 unparkSuccessor(h);//唤醒等待队列的下一个节点 return true; } return false; }

protected final boolean tryRelease(int releases) { int c = getState() - releases;//获取state值，释放给定的量 if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; if (c == 0) {//如果c=0,表示锁已经释放 free = true; setExclusiveOwnerThread(null);//表示当前没有线程占用锁 } setState(c);//如果c不等于0，表示锁还没有完全释放，设置状态 return free; }

private void unparkSuccessor(Node node) {//唤醒后继节点

int ws = node.waitStatus;//获取给定节点的等待状态
if (ws < 0)//如果等待状态小于0，则置为0
    compareAndSetWaitStatus(node, ws, 0);


Node s = node.next;//获取给定节点的下一个节点
if (s == null || s.waitStatus > 0) {//如果后继节点为null或者，等待状态>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);//唤醒 }

因此释放锁的过程可以总结为首先利用tryRelease尝试释放锁，如果失败，则返回false，否则调用unparkSuccessor方法去唤醒后继节点，成功则返回true。

1.2共享模式下获取锁

在前文中，我们讲了如果在独占模式获取锁和释放锁，接下来我们在看看在共享模式下如何获取锁和释放锁，在共享模式下获取锁的方式也是三种，分别是：不响应线程中断获取acquireShared，响应线程中断获取acquireSharedInterruptibly，设置超时时间获取tryAcquireSharedNanos。

1.2.1不响应线程中断获取

源码如下

public final void acquireShared(int arg) { if (tryAcquireShared(arg) < 0)//尝试获取锁 doAcquireShared(arg);//获取失败进入该方法 }

//尝试获取锁，由子类实现。1.负数表示获取失败；2.0表示获取成功，后继节点无法在获取；3.正数表示获取成功， //后继节点也可以获取成功 protected int tryAcquireShared(int arg) { throw new UnsupportedOperationException(); }

当获取锁失败之后，会调用doAcquireShared方法将当前线程构建成共享模式插入队列尾部，源码如下

private void doAcquireShared(int arg) { final Node node = addWaiter(Node.SHARED);//将当前线程包装成节点插入到队列尾部 boolean failed = true; try { boolean interrupted = false; for (;;) { final Node p = node.predecessor();//获取当前节点的前驱节点 if (p == head) { int r = tryAcquireShared(arg);//如果前驱节点为头节点，再次尝试获取锁 if (r >= 0) {//如果r>=0则表示获取锁成功 setHeadAndPropagate(node, r);//将自己设置为头节点，并 //且唤醒后面同样是共享模式的节点 p.next = null; // help GC if (interrupted) selfInterrupt();//如果在阻塞期间收到中断请求，则中断自己 failed = false; return; } } if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; } } finally { if (failed) cancelAcquire(node); } }

private void setHeadAndPropagate(Node node, int propagate) { Node h = head; // Record old head for check below setHead(node);//将给定节点设置为头节点

if (propagate > 0 || h == null || h.waitStatus < 0 ||
    (h = head) == null || h.waitStatus < 0) {
    Node s = node.next;//获取给定节点的后继节点
    if (s == null || s.isShared())
        doReleaseShared();//唤醒后继节点
}

}

从上述代码可以看出，如果当前节点获取到锁，并且值大于0，则表示后面的节点也会获取到锁，因此当前节点就需要去唤醒后面同样是共享模式的结点，即使当前节点的后继节点为null，也会将等待状态设置为PROPAGATE来告诉后来的线程这个锁是可获取状态。

1.2.2响应线程中断获取

源码如下

public final void acquireSharedInterruptibly(int arg) throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException();//判断线程是否中断，是抛出异常 if (tryAcquireShared(arg) < 0)//尝试获取锁 doAcquireSharedInterruptibly(arg);//获取失败进入该方法 }

private void doAcquireSharedInterruptibly(int arg) throws InterruptedException { final Node node = addWaiter(Node.SHARED); boolean failed = true; try { for (;;) { final Node p = node.predecessor(); if (p == head) { int r = tryAcquireShared(arg); if (r >= 0) { setHeadAndPropagate(node, r); p.next = null; // help GC failed = false; return; } } if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) throw new InterruptedException();//线程在阻塞过程中收到中断请求，立马抛出异常 } } finally { if (failed) cancelAcquire(node); } }

1.2.3设置超时间获取

源码如下

public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException();//响应中断 return tryAcquireShared(arg) >= 0 || doAcquireSharedNanos(arg, nanosTimeout);//尝试获取锁，失败则调用doAcquireSharedNanos方法 }

private boolean doAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException { if (nanosTimeout <= 0L) return false; final long deadline = System.nanoTime() + nanosTimeout; final Node node = addWaiter(Node.SHARED); boolean failed = true; try { for (;;) { final Node p = node.predecessor(); if (p == head) { int r = tryAcquireShared(arg); if (r >= 0) { setHeadAndPropagate(node, r); p.next = null; // help GC failed = false; return true; } } nanosTimeout = deadline - System.nanoTime(); if (nanosTimeout <= 0L) return false; if (shouldParkAfterFailedAcquire(p, node) && nanosTimeout > spinForTimeoutThreshold) LockSupport.parkNanos(this, nanosTimeout); if (Thread.interrupted()) throw new InterruptedException(); } } finally { if (failed) cancelAcquire(node); } }

如果第一次获取锁失败会调用doAcquireSharedNanos方法并传入超时时间，进入方法后会根据情况再次去获取锁，如果再次获取失败就要考虑将线程挂起了。这时会判断超时时间是否大于自旋时间，如果是的话就会将线程挂起一段时间，否则就继续尝试获取，每次获取锁之后都会将超时时间减去获取锁的时间，一直这样循环直到超时时间用尽，如果还没有获取到锁的话就会结束获取并返回获取失败标识。在整个期间线程是响应线程中断的。

1.3共享模式下释放锁

接下来我们再看看共享模式下是如何释放锁的，源码如下

public final boolean releaseShared(int arg) { if (tryReleaseShared(arg)) {//尝试释放锁 doReleaseShared();//成功则唤醒其他线程 return true; } return false; }

private void doReleaseShared() {

for (;;) {
    Node h = head;//获取队列头节点
    if (h != null && h != tail) {
        int ws = h.waitStatus;//获取头节点的等待状态
        if (ws == Node.SIGNAL) {//如果head结点的状态为SIGNAL, 表明后面有人在排队
            if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                continue;            // loop to recheck cases
            unparkSuccessor(h);//唤醒后继结点
        }

//如果head结点的状态为0, 表明此时后面没人在排队, 就只是将head状态修改为PROPAGATE else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) continue; // loop on failed CAS } if (h == head) // loop if head changed break; } }

首先调用tryReleaseShared方法尝试释放锁，该方法的判断逻辑由子类实现。如果释放成功就调用doReleaseShared方法去唤醒后继结点。另外如果没有没有后继节点，那么将状态设置为PROPAGATE。