Java并发之AQS（AbstractQueuedSynchronizer）原理讲解

一、什么是AQS？

    AQS的全称是AbstractQueuedSynchronizer，即抽象队列同步器，其底层是volatile与CAS，而其上层则是基于该抽象类构建的许多并发组件，如ReentrantLock、Semaphore等。AQS自身实现了一些基本方法，还剩余一些面向上层的方法，这些方法需要继承该抽象类的同步组件去实现。

    volatile原理链接

    CAS原理链接

    AQS最核心的数据结构是一个volatile int state 和 一个FIFO线程等待对列。state代表共享资源的数量，如果是互斥访问，一般设置为1，而如果是共享访问，可以设置为N（N为可共享线程的个数）；而线程等待队列是一个双向链表，无法立即获得锁而进入阻塞状态的线程会加入队列的尾部。当然对state以及队列的操作都是采用了volatile + CAS + 自旋的操作方式，采用的是乐观锁的概念。

    AQS有两种实现方式，一种是独占方式，另一种是共享方式（shared），取决于用户实现什么方法。

    下面来看一下AQS的线程等待队列图

                                                                                （图片来自网络）

二、AQS的核心方法（独占模式为例）

1、获取资源

（1）acquire方法，本方法时ReentrantLock方法的lock方法调用的方法。

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&    //尝试获取锁，若获取成功，则state减1，返回true
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) //若获取锁不成功，调用addWaiter方法使线程进入等待队列，acquireQueued方法让线程进入阻塞状态
            selfInterrupt(); //检查在等待过程中是否有中断，若有中断，则在此时再响应
}

（2）tryAcquire方法，本方法需要用户自己实现，但是不抽象的。

protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
}

为什么要抛出异常而不是声明为抽象类呢？Programer肯定有他自己的考虑，因为AQS是可选模式的，我们选择的是独占模式，就不需要去重写tryAcquireShared方法，如果我们选的是共享模式，也不需要重写tryAcquire方法，因此AQS虽然是抽象类，但是没有抽象方法，而是用抛出异常的方式代替。

具体重写的方法一般就是对state进行原子操作，若获取资源成功则返回true，否则返回false。

（3）addWaiter方法的主要是把当前线程加入到FIFO等待队列队尾。

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);//创建节点
        // 首先尝试快速插入队尾
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {//CAS操作
                pred.next = node;
                return node;
            }
        }
        enq(node);//若不成功，则尝试以自旋方式插入队尾
        return node;
}

private Node enq(final Node node) {
        for (;;) {//自旋方式不断尝试插入队尾，直至成功为止
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
}

（4）acquireQueued方法，主要是让加入队尾的线程进入等待状态，等到前面的进程执行完了，再唤醒该线程，去执行同步代码在这里是检测是否应该park()（park是一个Unsafe包中的native方法），以及检测在队列的等待过程中是否有中断，在等待过程中是不响应中断的，等到等待结束被唤醒时，才去向上传递是否中断过的值。

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

流程图：

2、释放资源的过程

（1）release方法

public final boolean release(int arg) {
        if (tryRelease(arg)) {//尝试释放资源，一般不会失败，state加一
            Node h = head;
            if (h != null && h.waitStatus != 0)//
                unparkSuccessor(h);//唤醒等待队列里的下一个线程
            return true;
        }
        return false;
}

（2）tryRelease方法，同样需要自己重写

protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
}