深入理解Java并发之AQS抽象队列同步器-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_24251607/article/details/124616420

一、什么是AQS

1. AQS的定义

AQS 的全称为 AbstractQueuedSynchronizer ，中文译为抽象队列式同步器。这个类在 java.util.concurrent.locks 包下面。这个抽象类对于JUC并发包非常重要，JUC包中的 ReentrantLock，Semaphore，ReentrantReadWriteLock，CountDownLatch 等等几乎所有的类都是基于AQS实现的。

2. AQS的原理/思想

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

队列：AQS其实就是基于 CLH队列 产生的，这个队列是一个双向队列，不存在队列示例，仅存在节点之间的关系。用 volatile 关键字来修饰其中的变量 state，线程利用 CAS 去改变这个值，改变成功则表示获取成功，否则就是获取失败，进入等待队列等待被唤醒。

tips：AQS是自旋锁，等待唤醒的时候会不断自旋尝试获取锁，直到锁被获取或被其他线程获取

AQS的实现方式如下：

AQS使用 private volatile int state 表示同步状态。通过内置的FIFO队列完成线程的排队。使用CAS对state进行修改。。

二、节点

第一节里我们提到 —— AQS 是基于 CLH 队列产生的，这个队列是一个虚拟的双向队列。这一节我们来看看这个队列里的节点。

在 AbstractQueuedSynchronizer 源码中，作者编写了 等待队列节点类，并赋予了类的解释：

等待队列是“CLH”（Craig、Landin和Hagersten）锁队列的变体。CLH锁通常用于旋转锁。相反，我们使用它们来阻止同步器，但使用相同的基本策略，即在其节点的前一个线程中保存一些关于该线程的控制信息。每个节点中的“状态”字段跟踪线程是否应该阻塞。当一个节点的前一个节点释放时，它会收到信号。队列的每个节点都充当一个特定的通知样式监视器，其中包含一个等待线程。

机器翻译读起来怪怪的，那就直接看这个类是什么样子吧：

static final class Node {
        static final Node SHARED = new Node();
        static final Node EXCLUSIVE = null;
    	// 队列中节点状态值 也就是 waitStatus
        static final int CANCELLED =  1;
        static final int SIGNAL    = -1;
        static final int CONDITION = -2;
        static final int PROPAGATE = -3;

    	// 队列中节点状态
        volatile int waitStatus;
    	// 前驱、后继
        volatile Node prev;
        volatile Node next;
    
        volatile Thread thread;

        Node nextWaiter;

        final boolean isShared() {
            return nextWaiter == SHARED;
        }
        
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }

        Node() {    // Used to establish initial head or SHARED marker
        }

        Node(Thread thread, Node mode) {     // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }

        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

以及最重要的成员：

private volatile int state;

线程获取或释放锁的本质是去修改AQS里的 state。比如说，我们创建一个ReentrantLock的实例，此时该锁实例内部的state为0，表征它还没有被任何线程所持有。当多个线程同时调用它的lock()方法获取锁时，它们的本质操作其实就是将该锁实例的state值由0修改为1，第1个抢到这个操作执行的线程就成功获取了锁，后续执行操作的线程就会看到state值已经为1了，即表明该锁已经被其他线程获取，它们抢占锁失败了。这些抢占锁失败的线程会被AQS放入到CHL队列里面去维护起来。

三、实现AQS

AQS支持线程抢占两种锁——独占锁和共享锁：

独占锁：同一个时刻只能被一个线程占有，如ReentrantLock，ReentrantWriteLock等，它又可分为：
公平锁：按照线程在队列中的排队顺序，先到者先拿到锁
非公平锁：当线程要获取锁时，无视队列顺序直接去抢锁，谁抢到就是谁的
共享锁：同一时间点可以被多个线程同时占有，如ReentrantReadLock，Semaphore等
AQS的所有子类中，要么使用了它的独占锁，要么使用了它的共享锁，不会同时使用它的两个锁。

在 AQS 的源码里，作者是这么说的：

要将此类用作同步器的基础，请通过使用getState、setState和/或compareAndSetState检查和/或修改同步状态，重新定义以下方法（如适用）：
tryAcquire
tryRelease
tryAcquireShared
tryReleaseShared
isHeldExclusively

//独占锁的获取锁与释放锁
//返回值表示获取锁是否成功
protected boolean tryAcquire(int arg){}
//返回值表示释放锁是否成功
protected boolean tryRelease(int arg){}

//共享锁的获取锁与释放锁
//返回值表示获得锁后还剩余的许可数量
protected int tryAcquireShared(int arg){}
//返回值表示释放锁是否成功
protected boolean tryReleaseShared(int arg){}

//调用该方法的线程是否持有独占锁，一般用到了condition的时候才需要实现此方法
protected boolean isHeldExclusively(){}

这些方法是子类需要实现的，可以选择实现其中的一部分。根据实现方式的不同，可以分为两种：独占锁和共享锁。

独占锁需要实现的是 tryAcquire(int)、tryRelease(int)
共享锁需要实现的是 tryAcquireShared(int)、tryReleaseShared(int)

以ReentrantLock为例：state初始化为0，表示未锁定状态，A线程lock()时，会调用tryAcquire()独占锁并将state+1.之后其他线程再想tryAcquire的时候就会失败，直到A线程unlock()到state=0为止，其他线程才有机会获取该锁。A释放锁之前，自己也是可以重复获取此锁（state累加），这就是可重入的概念。
注意：获取多少次锁就要释放多少次锁，保证state是能回到零态的。

以CountDownLatch为例，任务分N个子线程去执行，state就初始化为N，N个线程并行执行，每个线程执行完之后countDown（）一次，state就会CAS减一。当N子线程全部执行完毕，state=0，会unpark()主调用线程，主调用线程就会从await()函数返回，继续之后的动作。

1. ReentrantLock

ReentrantLock 默认采用非公平锁，因为考虑获得更好的性能，通过 boolean 来决定是否用公平锁（传入 true 用公平锁）。

private final Sync sync;
public ReentrantLock() {
        sync = new NonfairSync();
    }
public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

// 非公平锁的实现
static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    final void lock() {
        // 尝试直接获取锁
        if (compareAndSetState(0, 1))
            // 获取到了直接返回
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

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

// nonfairTryAcquire 方法
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;
}

// 公平锁的实现
static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

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

公平锁和非公平锁的不同：

非公平锁在调用 lock 之后，会直接调用 CAS 进行抢锁，如果此时锁未被占用，则直接获得锁并返回。
非公平锁 CAS 抢锁失败后，和公平锁一样都会通过 acquire(1) 进入到 tryAcquire 方法。在这个方法中，如果发现锁被释放了，也就是 state = 0，非公平锁会直接尝试 CAS 抢锁，公平锁会判断是否有线程处于等待状态，如果有则自行排到队列后等待唤醒。

2. CountDownLatch

CountDownLatch允许一个或者多个线程去等待其他线程完成操作。需要实现的是 tryAcquireShared(int)、tryReleaseShared(int)

private static final class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 4982264981922014374L;

    Sync(int count) {
        setState(count);
    }

    int getCount() {
        return getState();
    }

    protected int tryAcquireShared(int acquires) {
        return (getState() == 0) ? 1 : -1;
    }

    protected boolean tryReleaseShared(int releases) {
        // Decrement count; signal when transition to zero
        for (;;) {
            int c = getState();
            if (c == 0)
                return false;
            int nextc = c-1;
            if (compareAndSetState(c, nextc))
                return nextc == 0;
        }
    }
}

3. Mutex

本质上都是实现 tryAcquire(int)、tryRelease(int) 或者 tryAcquireShared(int)、tryReleaseShared(int)

class Mutex implements Lock, java.io.Serializable {

        // Our internal helper class
        private static class Sync extends AbstractQueuedSynchronizer {
            // Reports whether in locked state
            protected boolean isHeldExclusively() {
                return getState() == 1;
            }
            // Acquires the lock if state is zero
            public boolean tryAcquire(int acquires) {
                assert acquires == 1; // Otherwise unused
                if (compareAndSetState(0, 1)) {
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }
                return false;
            }
            // Releases the lock by setting state to zero
            protected boolean tryRelease(int releases) {
                assert releases == 1; // Otherwise unused
                if (getState() == 0) throw new IllegalMonitorStateException();
                setExclusiveOwnerThread(null);
                setState(0);
                return true;
            }
            // Provides a Condition
            Condition newCondition() {
                return new ConditionObject();
            }
            // Deserializes properly
            private void readObject(ObjectInputStream s)
                    throws IOException, ClassNotFoundException {
                s.defaultReadObject();
                setState(0); // reset to unlocked state
            }
        }
    }