Java多线程：AQS

在Java多线程：线程间通信之Lock中我们提到了ReentrantLock是API级别的实现，但是没有说明其具体实现原理。实际上，ReentrantLock的底层实现使用了AQS（AbstractQueueSynchronizer）。AQS本身仅仅是一个框架，定义了一套多线程访问共享资源的同步框架，可以实现ReentrantLock, Semaphore, CountDownLatch等多线程类。

AQS框架维护了一个资源state（volatile int）和一个同步队列。其中对state的访问包括三种方法：getState(), setState(), compareAndSetState()。其中，compareAndSetState()是原子操作，底层是CAS实现。

AQS框架包含两种可供选择的实现方式：独占(Exclusive)和共享(Share)。由于不同自定义同步器征用共享资源的方式不同，自定义同步器实现时只需实现共享资源state的获取与释放方式即可，而不需要考虑队列的维护。下面简述AQS框架中独占锁和共享锁的获取，释放流程。

独占锁流程

获取时首先调用acquire(acquires)，之后进入tryAcquire(acquires)尝试获取锁，若成功则返回。若失败则将当前线程构造为Node节点，CAS插入到同步队列尾部，该线程自旋。自旋时判断其前驱节点是否为头节点，是否成功获取同步状态，二者皆成立则当前节点设置为头节点，否则挂起当前线程等待被前驱节点唤醒。

释放时首先调用release(acquires)，之后进入tryRelease(acquires)释放同步状态，之后获取同步队列中当前节点的下一节点并唤醒。

共享锁流程

获取时首先调用acquireShared(acquires)，之后进入tryAcquireShared(acquires)获取同步状态，返回值不小于0则说明同步状态有剩余，获取成功直接返回。若返回值小于0则说明获取同步状态失败，构造Node节点CAS插入同步队列尾部并自旋检查前驱节点是否为头节点且成功获取同步状态，若是则当前节点设为头节点，否则挂起等待被前驱节点唤醒。

释放时调用releaseShared(acquires)释放同步状态，之后遍历整个队列唤醒所有后继节点。

独占锁和共享锁实现区别

• 独占锁的state值为1，同一时刻只有一个线程成功获取同步状态。共享锁state>1，取值由自定义同步器决定。
• 独占锁队列头节点运行完毕释放锁后唤醒直接后继节点，共享锁唤醒所有后继节点。
• 共享锁会出现多个线程同时成功获取同步状态的情况。

重入锁的实现

Java中的ReentrantLock和synchronized都是可重入锁，synchronized由JVM实现，重入锁实现时最主要的逻辑是判断上次获取锁的线程是否为当前线程，ReentrantLock基于AQS实现，提供公平锁和非公平锁两种方式，非公平锁实现逻辑如下：

final boolean nonfairTryAcquire(int acquires) {
            //获取当前线程
            final Thread current = Thread.currentThread();
            //通过AQS获取同步状态
            int c = getState();
            //同步状态为0，说明临界区处于无锁状态，
            if (c == 0) {
                //修改同步状态，即加锁
                if (compareAndSetState(0, acquires)) {
                    //将当前线程设置为锁的owner
                    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;
        }

公平锁的实现逻辑如下，与非公平锁的区别为判断当前节点是否存在前驱节点，只有等待前驱节点释放后才能获取锁。

protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                //此处为公平锁的核心，即判断同步队列中当前节点是否有前驱节点
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

读写锁的实现

Java的ReentrantReadWriteLock是读写锁实现，其原理是将state变量的高16位和低16位拆分，高16位表示读锁，低16位表示写锁。其写锁tryAcquire(acquires)实现如下:

• 获取同步状态，分离出低16位的写锁状态。
• 同步状态不为0，则存在读锁或写锁。
• 若存在读锁，则不能获取写锁。
• 若当前线程不是上次获取写锁的线程，则不能获取写锁。
• 以上判断通过，对低16位（写锁同步状态）进行CAS修改。
• 当前线程设为写锁的获取线程。

其读锁的tryAcquire(acquires)实现如下：

• 获取当前同步状态，计算高16位为读锁状态+1后的值。
• 若大于能获取到的读锁的最大值，则抛出异常。
• 若存在写锁且当前线程不是写锁获取者，则获取读锁失败。
• 若上述判断都通过，则利用CAS重新设置读锁的同步状态。

写写锁释放与普通独占锁基本相同，在写锁释放中不断减少读锁的同步状态，同步状态为0时才能完全释放；读锁释放过程中不断释放写锁状态，直到为0，表示没有线程获取读锁。

参考文献

Java技术之AQS详解

Java并发-AQS及各种Lock锁的原理