JUC系列之AQS

简介：

AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的ReentrantLock，Semaphore，其他的诸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基于AQS的。当然，我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的同步器。

关注公众号即可获取上百本前沿技术电子书、最新面试资料。

AQS的核心思想

AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。

CLH

CLH队列是一个虚拟的双向队列(虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系)。AQS是将每条请求共享资源的线程封装成一个CLH锁队列的一个结点(Node)来实现锁的分配。

条件队列

条件队列是指将一组线程通过某种方式组织起来，使它们等待的同一个条件变为真。与其它队列不同，条件队列中的元素是等待着的线程而不是数据，条件队列更像是一种多线程合作的设计模式。假设有一个栈，当我们向栈中放数据之前，需要先判断栈是不是已经满了，如果已经满了则需要等待栈不满；同理从栈中取出元素也要判断栈是否为空。

在AQS中来实现添加队列的对象是ConditionObject，ConditionObject是Condition接口的内部类。通常配合基于AQS实现的锁一同使用。当线程获取到锁之后，可以调用await方法进入条件队列并释放锁，或者调用singinal方法唤醒对应条件队列中等待时间最久的线程并加入到等待队列中。

在AQS中，线程会被封装成Node对象加入队列中，而条件队列中则复用了同步队列中的Node对象。

AQS中的核心实现是什么

AQS使用一个int成员变量来表示同步状态，通过内置的FIFO队列来完成获取资源线程的排队工作。AQS使用CAS对该同步状态进行原子操作实现对其值的修改。

// java.util.concurrent.locks.AbstractQueuedSynchronizer.Node

/**
 * 共享变量，使用volatile修饰保证线程可见性
 */
private volatile int state;
 
// 状态的操作

/**
 * 返回同步状态的当前值
 */
protected final int getState() {
    return state;
}

/**
 * 设置同步状态的值
 */
protected final void setState(int newState) {
    state = newState;
}

/**
 * CAS 设置值
 */
protected final boolean compareAndSetState(int expect, int update) {
    // See below for intrinsics setup to support this
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
 

AQS对资源的共享方式

1. 共享： 多个线程可同时执行，如Semaphore/CountDownLatch。Semaphore、CountDownLatCh、 CyclicBarrier、ReadWriteLock

2. 独占： 资源只能一个线程进行获取或者一个线程运行。如ReentrantLock。又可分为公平锁和非公平锁：

公平锁：按照线程在队列中的排队顺序，先到者先拿到锁

非公平锁：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的

AQS核心的方法

AQS在整体的设计上是通过模板方法来进行设计的，实现自定义的同步器类，就需要对几个核心的方法进行重写，在父类默认上这些方法都是会抛出UnsupportedOperationException异常。

核心方法

// 该线程是否正在独占资源。使用条件对立condition才需要去实现它。
isHeldExclusively()

//独占方式。尝试获取资源，成功则返回true，失败则返回false。
tryAcquire(int)

//独占方式。尝试释放资源，成功则返回true，失败则返回false。
tryRelease(int)

//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
tryAcquireShared(int)

//共享方式。尝试释放资源，成功则返回true，失败则返回false。
tryReleaseShared(int)

ReentrantLock内部实现

下面我们看看ReentrantLock内部是如何实现这些方法，可以参考阅读下

tryAcquire(int)

// java.util.concurrent.locks.ReentrantLock.NonfairSync

protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

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

tryRelease(int)

// java.util.concurrent.locks.ReentrantLock.Sync

protected final boolean tryRelease(int releases) {
    // releases 永远都是1 每次释放锁就是值减1 重入锁也是一次次的释放，所以加锁和释放锁 总是成对出现的。
    int c = getState() - releases;
    // 如果当前线程不是获取锁的线程就报错
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 等于0则需要释放资源，让别的线程进行竞争。
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    // 重入锁， 需要继续释放。
    setState(c);
    return free;
}

以上是tryRelease和tryAcquire的简易描述，可以看到通过模板方法，开发者只需要实现很简单的代码，就能实现同步器的功能，但是需要注意的是，这些方法的实现要尽量的高效和简短。

---

结语

纸上得来终觉浅，绝知此事要躬行。 每个技术并不神秘，我们只要去探索它，就能发现它的奥秘。