抽象队列同步器AQS

    AQS全名为AbstractQueuedSynchronizer,为java并发包中提供的类。提供了对资源占用，释放，线程的等待、唤醒等接口和具体实现，

能够用在各类须要控制资源争用的场景中。(ReentrantLock/CountDownLatch/Semphore)

   

    AQS中定义了八个比较重要的方法：

      acquire、acruireShared:定义了资源争用的逻辑，若是没拿到，则等待

      tryAcquire、tryAcquireShared：实际执行占用资源的逻辑，如何断定由使用者具体去实现

      release、releaseShared：定义资源释放的逻辑，释放以后，通知后续节点进行争抢

      tryRelease、tryReleaseShared：定义执行资源释放的操做，具体的AQS使用者去实现

 

    资源占用流程

   

 

     以ReentrantLock为例，分析AQS的使用。因为ReentrantLock是独占锁，因此会涉及到 acquire、tryAcquire、release、tryRelease四个方法。

 ReentrantLock中Sync类继承了AQS，其中关键代码以下：

abstract static class Sync extends AbstractQueuedSynchronizer { /** * Performs {@link Lock#lock}. The main reason for subclassing * is to allow fast path for nonfair version. */
        abstract void lock(); .... /** *非公平获取锁，每次获取时都尝试获取一次，无论前面是否有其余 *线程也在尝试获取，获取失败则加入等待队列 * 获取成功则将锁持有者设为当前线程 */
        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; } /** *尝试释放锁 *即将state变量减一，当state为0时返回释放成功 */
        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中有公平锁和非公平锁两种实现。在ReentrantLock中对应了两个类，NonfairSync和FairSync，它们都继承了Sync。

     FairSync关键代码以下：

static final class FairSync extends Sync { ··· /** *加锁方法，首先调用tryAcquire方法，成功则获取锁 *不然经过aqs提供的方法将当前线程加入等待队列 */
        final void lock() { acquire(1); } /** *若是state为0则尝试获取锁，若是前面有线程也尝试获取锁则把当前线程加入等待队列 *state不为0则则判断持有锁的线程是否时当前线程，是则state加一（锁的可重入机制） */
        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; } }

 

      NonfairSync关键代码以下：

static final class NonfairSync extends Sync { ··· /** *非公平锁加锁时老是先尝试获取锁 *即尝试经过CAS将state由0设为1 * 设置失败则调用acquire方法 */
        final void lock() { if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); } /** * tryAcquire方法调用父类Sync的nonfairTryAcquire方法 */
        protected final boolean tryAcquire(int acquires) { return nonfairTryAcquire(acquires); } }

 

  接下来再查看ReentrantLock的加锁与解锁方法，即在调用Sync的acruire和release方法：

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