AbstractQueuedSynchronizer 详解

一、AQS的概念及使用

　　Java并发编程核心在于 java.concurrent.util 包而juc当中的大多数同步器实现都是围绕着共同的基础行为，比如等待队列、条件队列、独占获取、共享获取等，而这个行为的抽象就是基于 AbstractQueuedSynchronizer 简称AQS，AQS定义了一套多线程访问共享资源的同步器框架，是一个依赖状态(state)的同步器。

　　子类们必须定义改变state变量的protected方法，这些方法定义了state是如何被获取或释放的。鉴于此，本类中的其他方法执行所有的排队和阻塞机制。子类也可以维护其他的state变量，但是为了保证同步，必须原子地操作这些变量。

　　AbstractQueuedSynchronizer会把所有的请求线程构成一个CLH队列，当一个线程执行完毕（lock.unlock()）时会激活自己的后继节点，但正在执行的线程并不在队列中，而那些等待执行的线程全部处于阻塞状态。

　　AQS是一个同步器，设计模式是模板模式。核心数据结构：双向链表 + state(锁状态)；底层操作：CAS

 Java.concurrent.util当中同步器的实现如Lock，Latch，Barrier 等，都是基于AQS框架实现 ；

• 一般通过定义内部类Sync继承AQS ；
  
• 将同步器所有调用都映射到Sync对应的方法; 

ReentrantLock主要方法：

• lock()获得锁
• lockInterruptibly()获得锁，但优先响应中断
• tryLock()尝试获得锁，成功返回true,否则false，该方法不等待，立即返回
• tryLock(long time,TimeUnit unit)在给定时间内尝试获得锁
• unlock()释放锁

Condition：await()、signal()方法分别对应之前的Object的wait()和notify()

• 和重入锁一起使用
• await()是当前线程等待同时释放锁
• awaitUninterruptibly()不会在等待过程中响应中断
• signal()用于唤醒一个在等待的线程，还有对应的singalAll()方法

二、AQS源码分析

我们以 ReentrantLock(独占锁)作为切入点来学习 AbstractQueuedSynchronizer；

1、ReentrantLock 和 AbstractQueuedSynchronizer 的部分代码

ReentrantLock的内部类 Sync 继承了 AbstractQueuedSynchronizer 类， Sync的两个子类又实现了非公平锁和公平锁；

class ReentrantLock {
    class Sync extends AbstractQueuedSynchronizer{
        abstract void lock(); //加锁, 子类需求重写该方法
    }

    //非公平锁, 默认
    class NonfairSync extends Sync {
       //省略 lock()的实现
    }
    
    //公平锁
    static final class FairSync extends Sync {
        //省略 lock()的实现
    }
}

 

 AQS源码中的属性：

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer {
    private transient volatile Node head; //头结点
    
    //阻塞的尾节点，每个新的节点进来，都插入到最后，也就形成了一个链表
    private transient volatile Node tail; 
    
    //代表当前锁的状态，0代表没有被占用，大于0代表有线程持有当前锁，这个值可以大于1，是因为锁可以重入，每次重入都加1
    private volatile int state;    

    //AbstractOwnableSynchronizer(AQS的父类)的属性,代表当前持有独占锁的线程，举个最重要的使用例子，因为锁可以重入
    private transient Thread exclusiveOwnerThread;
}

AQS源码中的内部类 Node：

static final class Node {
    static final Node SHARED = new Node();    //标记节点为共享模式
    static final Node EXCLUSIVE = null;       //标记节点为独占模式
    
    /* 下面的4个常量是给waitStatus用的 */
    static final int CANCELLED = 1static final int SIGNAL = -1static final int CONDITION = -2static final int PROPAGATE = -3;

    /**
     * 标记当前节点的信号量状态 (1,0,-1,-2,-3)5种状态
     * 使用CAS更改状态，volatile保证线程可见性，高并发场景下，
     * 即被一个线程修改后，状态会立马让其他线程可见。
     */
    volatile int waitStatus;

    volatile Node prev;    //前驱节点，当前节点加入到同步队列中被设置
    volatile Node next;    //后继节点
    volatile Thread thread;  //节点同步状态的线程
}

2、锁实现（加锁 Lock.lock()）

非公平锁：无论CLH队列中是否有节点，当前线程都要和队列头的节点去竞争一下锁；若竞争到锁，则该线程去持有锁；若没有竞争到锁，则放入到CLH队列尾部；

公平锁：无论CLH队列中是否有节点，当前线程都是去放到队列的尾部；

2.1 非公平锁实现

static final class NonfairSync extends Sync {
    final void lock() {
        if (compareAndSetState(0, 1)) //用CAS算法尝试获取锁
            setExclusiveOwnerThread(Thread.currentThread());  //当前线程占用锁
        else
            acquire(1);
    }
}

（1）若没有加锁(state == 0)，则直接让当前线程占有锁；

（2）若已经加锁了(state > 0)，则执行 AbstractQueuedSynchronizer.acquire(int arg)方法，代码如下；

public final void acquire(int arg) {
    if (!tryAcquire(arg) && //尝试获取锁
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

<1> 使用 NonfairSync.tryAcquire(arg)方法去尝试获取锁，它调用了 Sync.nonfairTryAcquire(int acquires) 方法；

<2> 若尝试获取锁失败，则调用 AbstractQueuedSynchronizer.addWaiter(Node.EXLUSIVE) 方法将当前线程放入到CLH队列;
<3> AbstractQueuedSynchronizer.acquireQueued（）方法把已经追加到队列的线程节点（addWaiter方法返回值）进行阻塞;

Sync.nonfairTryAcquire
该方法主要是去尝试获取锁（加锁）

final boolean nonfairTryAcquire(int acquires) {
    //acquires = 1
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) { //unsafe操作，cas修改state状态
            setExclusiveOwnerThread(current); //独占状态锁持有者指向当前线程
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) { //state状态不为0，锁持有者是当前线程，则state+1
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false; //加锁失败
}

a. 首先判断当前状态，若 c==0 说明没有线程占用该锁，并在占用锁成功之后将锁指向当前线程；

b. 如果 c != 0 说明有线程正拥有了该锁，而且若占用该锁就是当前线程（锁重入），则将 state 加 1；这段的代码只是简单地++acquires，并修改status值，是因为没有竞争获取锁的本身就是当前线程，所以通过setStatus修改state，而非CAS。

 

AbstractQueuedSynchronizer.addWaiter

addWaiter方法负责把当前无法获得锁的线程包装为一个Node节点添加到队尾：

private Node addWaiter(Node mode) {
    // 将当前线程构建成Node类型
    Node node = new Node(Thread.currentThread(), mode);
    
    Node pred = tail;
    if (pred != null) {   //若当前尾节点不是null
        node.prev = pred; //将当前节点的pre指向tail节点
        if (compareAndSetTail(pred, node)) { // CAS将节点插入同步队列的尾部
            pred.next = node;
            return node;
        }
    }
    enq(node); //将节点加入CLH同步队列
    return node;
}

其中参数mode是独占锁还是共享锁，默认为Node.EXCLUSIVE（null），独占锁。追加到队尾的动作分两步：

 <1> 如果当前队尾已经存在(tail!=null)，则使用CAS把当前线程更新为Tail

 <2> 如果当前Tail为 null 或则线程调用CAS设置队尾失败，则通过enq方法继续设置Tail

enq方法如下：

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;
            //set尾部节点
            if (compareAndSetTail(t, node)) {//当前节点置为尾部
                t.next = node; //前驱节点的next指针指向当前节点
                return t;
            }
        }
    }
}

　　该方法就是循环调用CAS，即使有高并发的场景，无限循环将会最终成功把当前线程追加到队尾（或设置队头）。总而言之，addWaiter的目的就是通过CAS把当前现在追加到队尾，并返回包装后的Node实例。

把线程要包装为Node对象的主要原因，除了用Node构造供虚拟队列外，还用Node包装了各种线程状态；

 

AbstractQueuedSynchronizer.acquireQueued

acquireQueued的主要作用是把已经追加到队列的线程节点（addWaiter方法返回值）进行阻塞，但阻塞前又通过 tryAccquire 重试是否能获得锁，如果重试成功能则无需阻塞，这就是非公平锁。

//已经在队列当中的Thread节点，准备阻塞等待获取锁
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)) {//② 如果前驱结点是头结点，才tryAcquire，其他结点是没有机会tryAcquire的。

                setHead(node);//获取同步状态成功，将当前结点设置为头结点。
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            
            /**
             * 如果前驱节点不是Head，通过shouldParkAfterFailedAcquire判断是否应该阻塞
             * 前驱节点信号量为-1，当前线程可以安全被parkAndCheckInterrupt用来阻塞线程
             */
            if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt()) //阻塞线程  ①
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

仔细看看这个方法是个无限循环，感觉如果 p == head && tryAcquire(arg)条件不满足循环将永远无法结束，当然不会出现死循环，奥秘在于第12行的parkAndCheckInterrupt会把当前线程挂起，从而阻塞住线程的调用栈。

程序执行到 ① 之后会就会阻塞当前的线程T1；若这个T1线程是放在CLH 队列头的，当有其他线程将锁释放之后会去唤醒这个线程T1；线程T1会继续自旋，执行到 ② 处，会再次去尝试获取锁；

下面是 shouldParkAfterFailedAcquire方法

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        //若前驱结点的状态是SIGNAL，意味着当前结点可以被安全地park
        return true;
    if (ws > 0) {
        // 前驱节点状态如果被取消状态，将被移除出队列
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /* 当前驱节点waitStatus为 0 or PROPAGATE状态时，
         * 将其设置为SIGNAL状态，然后当前结点才可以可以被安全地park
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

检查原则：

规则1：如果前继的节点状态为SIGNAL，表明当前节点需要unpark，则返回成功，此时acquireQueued方法的第12行（parkAndCheckInterrupt）将导致线程阻塞

规则2：如果前继节点状态为CANCELLED(ws>0)，说明前置节点已经被放弃，则回溯到一个非取消的前继节点，返回false，acquireQueued方法的无限循环将递归调用该方法，直至规则1返回true，导致线程阻塞

规则3：如果前继节点状态为非SIGNAL、非CANCELLED，则设置前继的状态为SIGNAL，返回false后进入acquireQueued的无限循环，与规则2同

总体看来，shouldParkAfterFailedAcquire就是靠前继节点判断当前线程是否应该被阻塞，如果前继节点处于CANCELLED状态，则顺便删除这些节点重新构造队列。

 

3、解锁( Lock.unlock() )

解锁代码相对简单，主要体现在AbstractQueuedSynchronizer.release 和 Sync.tryRelease方法中：

AbstractQueuedSynchronizer.release方法

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

release的语义在于：如果可以释放锁，则唤醒队列第一个线程（Head）;

Sync.tryRelease 方法

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

tryRelease语义很明确：如果线程多次锁定，则进行多次释放，直至status==0则真正释放锁，所谓释放锁即设置status为0，因为无竞争所以没有使用CAS。

AbstractQueuedSynchronizer.unparkSuccessor 方法

用于唤醒队列中的第一个线程(head)

private void unparkSuccessor(Node node) {
    //获取wait状态
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);// 将等待状态waitStatus设置为初始值0

    /**     若后继结点为空，或状态为CANCEL（已失效），则从后尾部往前遍历找到最前的一个处于正常阻塞状态的结点进行唤醒
     */
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);//唤醒线程
}

 

注意：

I.  若有T1、T2两个线程的时候，所以有一个线程要会放入到队列中，CLH会创建一个节点（pre=null，thread=null，next=下级节点），head 和 tail 都指向该节点；

II.  AQS的唤醒不会唤醒队列中的所有节点，而是依次去唤醒的；notify 和 notifyall 不能去指定线程唤醒的；

III. AQS中的线程阻塞是使用 Unsafe 魔术类当中的 park() 和 unpark() 做的；

 参考：https://www.jianshu.com/p/279baac48960