Java学习——AQS解析

最近在学习JUC，发现里面大部分的并发组件都是基于AQS，因此研读了一下源码，在此做个笔记。

AQS（AbstractQueuedSynchronizer）翻译为抽象队列同步器，是除Synchronized关键字外java自带的锁机制。

AQS使用一个int类型变量state来表示线程要竞争的资源，state的值即为可获取的资源数，当一个线程尝试获取锁时，会使用CAS方式去尝试改变state的值，如果改变成功，即获取了锁。CAS的实现是使用了Unsafe类底下的一系列compareAndSet*方法，这些方法调用了JAVA的native方法，可以认为是系统底层支持的原子操作。

 private final boolean compareAndSetHead(Node update);
 private final boolean compareAndSetTail(Node expect, Node update);
 private static final boolean compareAndSetWaitStatus(Node node,int expect,int update) ;
 private static final boolean compareAndSetNext(Node node,Node expect,Node update)

当线程尝试获取锁时，AQS会将线程封装为一个节点，放入到一个等待队列中。这个等待队列是一个FIFO的双向队列，处于等待队列中的线程获取锁失败后，会调用LockSupport类中的park方法，使等待的线程放弃调度资格，进入time_waiting的状态。所以AQS的状态通常如下图所示。总是位于header的线程持有锁，处于running状态，剩余的等待线程处于time-waitting状态（此处以独占模式为例），当header的线程执行完，释放锁时，将优先唤醒header节点的下一节点的线程进行锁的申请。

如下代码是等待队列中的线程尝试获取锁的处理过程，可以看出，等待线程以自旋的方式，循环尝试获取锁。在header节点线程释放锁时，会优先唤醒header节点的下一节点，但是被唤醒的线程并不一定能获取锁，还是得进行获取锁的尝试，如果失败，会进入time-waiting状态，继续等待被唤醒。

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
            	//获取当前节点的上一节点
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

在文章开头，笔者说过，juc中有很多并发组件是利用AQS实现的，这里，我以ReenTrantLock为例，介绍一下java的并发组件是怎样以AQS为基础设计实现锁。
ReenTrantLock是使用AQS实现的一种独占锁，可以是非公平锁或者公平锁，我们以实现比较简单的的非公平锁为例，锁使用最基本的两个接口实现为Lock和unLock，分别表示申请锁和释放锁。

从流程图可以看出，AQS实现了一整套的线程阻塞等待、线程被唤醒时的组织机制，而ReentrantLock为了实现非公平锁，只需要重写tryAcquire和tryRelease方法，这两个方法分别表示非阻塞方式的尝试获取锁和非阻塞方式的释放锁。

 final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return 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;
        }

ReenTrantLock的tryAcquire方法会调用nonfairTryAcquire方法，实现了非阻塞获取锁的处理逻辑，而且也实现了可重入机制，当获得锁的线程再次申请锁时，只是简单的对state值进行修改。

//in AQS
public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
            	//释放header的下一节点
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
//rewrite in ReentrantLock
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的unlock方法会调用AQS的release方法，release方法定义了锁释放的一系列操作，包括下一节点的唤醒。这实际上是一种模板方法的设计模式，而ReenTrantLock重写的tryRelease方法只是简单的实现了锁的释放。