AbstractQueuedSynchronizer(AQS) 超详细原理解析

java.util.concurrent包中很多类都依赖于这个类AbstractQueuedSynchronizer所提供的队列式的同步器,比如说常用的ReentranLock,Semaphore和CountDownLatch等.  为了方便理解,我们以一段使用ReentranLock的代码为例,讲解ReentranLock每个方法中有关AQS的使用.

ReentranLock示例

 我们都知道ReentranLock的加锁行为和Synchronized类似,都是可重入的锁,但是二者的实现方式确实完全不同的,我们之后也会讲解Synchronized的原理.除此之外,Synchronized的阻塞无法被中断,而ReentrantLock则提供了可中断的阻塞下面的代码是ReentranLock的相关API,我们就以此为顺序,依次讲解.

公平锁和非公平锁

 ReentranLock分为公平锁和非公平锁.二者的区别就在获取锁是否和排队顺序相关.我们都知道,如果当前锁被另一个线程持有,那么当前申请锁的线程会被挂起等待,然后加入一个等待队列里.理论上,先调用lock函数被挂起等待的线程应该排在等待队列的前端,后调用的就排在后边.如果此时,锁被释放,需要通知等待线程再次尝试获取锁,公平锁会让最先进入队列的线程获得锁,而非公平锁则会唤醒所有线程,让它们再次尝试获取锁,所以可能会导致后来的线程先获得了锁,则就是非公平.

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();

我们会发现FairSync和NonfairSync都继承了Sync类,而Sync的父类就是AbstractQueuedSynchronizer.但是AQS的构造函数是空的,并没有任何操作.  之后的源码分析,如果没有特别说明,就是指公平锁.

lock操作

 ReentranLock的lock函数如下所示,直接调用了sync的lock函数.也就是调用了FairSync的lock函数.

//ReentranLock
    public void lock() {
        sync.lock();
        }
    //FairSync
    final void lock() {
        acquire(1);//调用了AQS的acquire函数,这是关键函数之一

好,我们接下来就正式开始AQS相关的源码分析了,acquire函数你可以将其理解为获取一个同一时间只能有一个函数获取的量,这个量就是锁概念的抽象化.我们先分析代码,你慢慢就会明白其中的含义.

public final void acquire(int arg) {
        if (!tryAcquire(arg) && //tryAcquire先尝试获取"锁",//如果成功,直接返回,失败继续执行后续代码
            //addWaiter是给当前线程创建一个节点,并将其加入等待队列
            //acquireQueued是当线程已经加入等待队列之后的行为.
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
}

tryAcquire,addWaiter和acquireQueued都是十分重要的函数,我们接下来依次学习一下这些函数,理解它们的作用.

 1 //AQS类中的变量.
 2     private volatile int state;
 3     //这是FairSync的实现,AQS中未实现,子类按照自己的需要实现该类
 4     protected final boolean tryAcquire(int acquires) {
 5         final Thread current = Thread.currentThread();
 6         //获取AQS中的state变量,代表抽象概念的锁.
 7         int c = getState();
 8         if (c == 0) { //值为0,那么当前独占性变量还未被线程占有
 9             if (!hasQueuedPredecessors() && //如果当前阻塞队列上没有先来的线程在等待,UnfairSync这里的实现就不一致
10                 compareAndSetState(0, acquires)) {
11                 //成功cas,那么代表当前线程获得该变量的所有权,也就是说成功获得锁
12                 setExclusiveOwnerThread(current);
13                 return true;
14             }
15         }
16         else if (current == getExclusiveOwnerThread()) {
17             //如果该线程已经获取了独占性变量的所有权,那么根据重入性
18             //原理,将state值进行加1,表示多次lock
19             //由于已经获得锁,该段代码只会被一个线程同时执行,所以不需要
20             //进行任何并行处理
21             int nextc = c + acquires;
22             if (nextc < 0)
23                 throw new Error("Maximum lock count exceeded");
24             setState(nextc);
25             return true;
26         }
27         //上述情况都不符合,说明获取锁失败
28         return false;
29      }

       由上述代码我们可以发现,tryAcquire就是尝试获取那个线程独占的变量state.state的值表示其状态:如果是0,那么当前还没有线程独占此变量;否在就是已经有线程独占了这个变量,也就是代表已经有线程获得了锁.但是这个时候要再进行一次判断,看是否是当前线程自己获得的这个锁,如果是,那么就增加state的值.

ReentranLock获得锁

 这里有几点需要说明一下,首先是compareAndSetState函数,这是使用CAS操作来设置state的值,而且state值设置了volatile修饰符,通过这两点来确保修改state的值不会出现多线程问题.然后是公平锁和非公平锁的区别问题,在UnfairSync的nonfairTryAcquire函数中不会在相同的位置上调用hasQueuedPredecessors来判断当前是否已经有线程在排队等待获得锁.  如果tryAcquire返回true,那么就是获取锁成功,如果返回false,那么就是未获得锁.需要加入阻塞等待队列.我们下面就来看一下addWaiter的相关操作

等待锁的阻塞队列

 将保存当前线程信息的节点加入到等待队列的相关函数中涉及到了无锁队列的相关算法,由于在AQS中只是将节点添加到队尾,使用到的无锁算法也相对简单.真正的无锁队列的算法我们等到分析ConcurrentSkippedListMap时在进行讲解.

 1 private Node addWaiter(Node mode) {
 2         Node node = new Node(Thread.currentThread(), mode);
 3         //先使用快速如列法来尝试一下,如果失败,则进行更加完备的如列算法.
 4         Node pred = tail;//列尾指针
 5         if (pred != null) {
 6             node.prev = pred; //步骤1:该节点的前趋指针指向tail
 7             if (compareAndSetTail(pred, node)){ //步骤二:cas将尾指针指向该节点
 8                 pred.next = node;//步骤三:如果成果,让旧列尾节点的next指针指向该节点.
 9                 return node;
10             }
11         }
12         //cas失败,或在pred == null时调用enq
13         enq(node);
14         return node;
15         }
16     private Node enq(final Node node) {
17         for (;;) { //cas无锁算法的标准for循环,不停的尝试
18             Node t = tail;
19             if (t == null) { //初始化
20                 if (compareAndSetHead(new Node())) //需要注意的是head是一个哨兵的作用,并不代表某个要获取锁的线程节点
21                     tail = head;
22             } else {
23                 //和addWaiter中一致,不过有了外侧的无限循环,不停的尝试,自旋锁
24                 node.prev = t;
25                 if (compareAndSetTail(t, node)) {
26                     t.next = node;
27                     return t;
28                 }
29             }
30         }
31 }

       通过调用addWaiter函数,AQS将当前线程加入到了等待队列,但是还没有阻塞当前线程的执行,接下来我们就来分析一下acquireQueued函数.

等待队列节点的操作

 由于进入阻塞状态的操作会降低执行效率,所以,AQS会尽力避免试图获取独占性变量的线程进入阻塞状态.所以,当线程加入等待队列之后,acquireQueued会执行一个for循环,每次都判断当前节点是否应该获得这个变量(在队首了),如果不应该获取或在再次尝试获取失败,那么就调用shouldParkAfterFailedAcquire判断是否应该进入阻塞状态,如果当前节点之前的节点已经进入阻塞状态了,那么就可以判定当前节点不可能获取到锁,为了防止CPU不停的执行for循环,消耗CPU资源,调用parkAndCheckInterrupt函数来进入阻塞状态.

 1 final boolean acquireQueued(final Node node, int arg) {
 2         boolean failed = true;
 3         try {
 4             boolean interrupted = false;
 5             for (;;) { //一直执行,直到获取锁,返回.
 6                 final Node p = node.predecessor(); 
 7                 //node的前驱是head,就说明,node是将要获取锁的下一个节点.
 8                 if (p == head && tryAcquire(arg)) { //所以再次尝试获取独占性变量
 9                     setHead(node); //如果成果,那么就将自己设置为head
10                     p.next = null; // help GC
11                     failed = false;
12                     return interrupted;//此时,还没有进入阻塞状态,所以直接返回false,表示不需要中断
13                 }
14                 //判断是否要进入阻塞状态.如果`shouldParkAfterFailedAcquire`返回true,表示需要进入阻塞
15                 //调用parkAndCheckInterrupt,否在表示还可以再次尝试获取锁,继续进行for循环
16                 if (shouldParkAfterFailedAcquire(p, node) &&
17                     parkAndCheckInterrupt())
18                     //调用parkAndCheckInterrupt进行阻塞,然后返回是否为中断状态
19                     interrupted = true;
20             }
21         } finally {
22             if (failed)
23                 cancelAcquire(node);
24         }
25         }
26     private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
27         int ws = pred.waitStatus;
28         if (ws == Node.SIGNAL) //前一个节点在等待独占性变量释放的通知,所以,当前节点可以阻塞
29             return true;
30         if (ws > 0) { //前一个节点处于取消获取独占性变量的状态,所以,可以跳过去
31             //返回false
32             do {
33                 node.prev = pred = pred.prev;
34             } while (pred.waitStatus > 0);
35             pred.next = node;
36         } else {
37             //将上一个节点的状态设置为signal,返回false,
38             compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
39         }
40         return false;
41         }
42     private final boolean parkAndCheckInterrupt() {
43         LockSupport.park(this); //将AQS对象自己传入
44         return Thread.interrupted();
45         }

阻塞和中断

 由上述分析,我们知道了AQS通过调用LockSupport的park方法来执行阻塞当前进程的操作.其实,这里的阻塞就是线程不再执行的含义.通过调用这个函数,线程进入阻塞状态,上述的lock操作也就阻塞了.等待中断或在独占性变量被释放.

1 public static void park(Object blocker) {
2         Thread t = Thread.currentThread();
3         setBlocker(t, blocker);//设置阻塞对象,用来记录线程被谁阻塞的,用于线程监控和分析工具来定位
4         UNSAFE.park(false, 0L);//让当前线程不再被线程调度,就是当前线程不再执行.
5         setBlocker(t, null);
6 }

关于中断的相关知识,我们以后再说,就继续沿着AQS的主线,看一下释放独占性变量的相关操作吧ReentrantLock未获得阻塞,加入队列

unlock操作

 与lock操作类似,unlock操作调用了AQS的relase方法,参数和调用acquire时一样,都是1.

public final boolean release(int arg) {
        if (tryRelease(arg)) { //释放独占性变量,起始就是将status的值减1,因为acquire时是加1
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);//唤醒head的后继节点
            return true;
        }
        return false;
}

由上述代码可知,release就是先调用tryRelease来释放独占性变量,如果成功,那么就看一下是否有等待锁的阻塞线程,如果有,就调用unparkSuccessor来唤醒他们.

 1 protected final boolean tryRelease(int releases) {
 2         //由于只有一个线程可以获得独占先变量,所以,所有操作不需要考虑多线程
 3         int c = getState() - releases; 
 4         if (Thread.currentThread() != getExclusiveOwnerThread())
 5             throw new IllegalMonitorStateException();
 6         boolean free = false;
 7         if (c == 0) { //如果等于0,那么说明锁应该被释放了,否在表示当前线程有多次lock操作.
 8             free = true;
 9             setExclusiveOwnerThread(null);
10         }
11         setState(c);
12         return free;
13 }

我们可以看到tryRelease中的逻辑也体现了可重入锁的概念,只有等到state的值为1时,才代表锁真正被释放了.所以独占性变量state的值就代表锁的有无.当state=0时,表示锁未被占有,否在表示当前锁已经被占有.

 1 private void unparkSuccessor(Node node) {
 2         .....
 3          //一般来说,需要唤醒的线程就是head的下一个节点,但是如果它获取锁的操作被取消,或在节点为null时
 4          //就直接继续往后遍历,找到第一个未取消的后继节点.
 5         Node s = node.next;
 6         if (s == null || s.waitStatus > 0) {
 7             s = null;
 8             for (Node t = tail; t != null && t != node; t = t.prev)
 9                 if (t.waitStatus <= 0)
10                     s = t;
11         }
12         if (s != null)
13             LockSupport.unpark(s.thread);
14 }

调用了unpark方法后,进行lock操作被阻塞的线程就恢复到运行状态,就会再次执行acquireQueued中的无限for循环中的操作,再次尝试获取锁.

ReentrantLock释放锁并通知阻塞线程恢复执行

原文链接：https://blog.csdn.net/u010325193/article/details/84485908