CountDownLatch源码解析

Posted 不懂是非

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了CountDownLatch源码解析相关的知识,希望对你有一定的参考价值。

  一、CountDownLatch介绍

      CountDownLatch是在jdk1.5被引入的,它主要是通过一个计数器来实现的,当在初始化该类的构造函数时,会事先传入一个状态值,之后在执行await方法后,

    在这个状态值为0之前,当前线程(指的是调用await的线程)会一直等待。它内部使用了AQS来实现的,且是共享锁,具体怎么实现,待会看看它的实现原理。

      它的应用场景:

      一般在于在执行当前线程之前,要完成n个线程的任务,才能执行当前线程。这种场景适合用countdownLatch。

   二、源码解析

      先来看看该类的构造,如下图

      

      如图,红色框选中的是该类的一个内部类,该内部类实现了抽象类AQS,具体锁的获取和释放是由该内部类实现的。

     由上图知countdownLatch只有一个构造函数,    

1    public CountDownLatch(int count) {
2         if (count < 0) throw new IllegalArgumentException("count < 0");
3         this.sync = new Sync(count);
4     }

 

    很明显,它有一个参数,这个参数,被用在哪里呢,请看下面

1      Sync(int count) {
2             setState(count);
3         }

 

     这个参数最终用在了状态值上,由此可猜测,这个状态值决定这锁什么时候释放。

      1、内部类Sync

        

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

        Sync(int count) {
            setState(count);//设置状态值的大小
        }

        int getCount() {
            return getState();//获取状态值
        }
    //当状态值为0才返回1,否则返回-1,也用来判断线程是否拥有该锁,值大于0,不拥有,小于0,则拥有
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }
     //对状态值进行操作,每一次成功,则状态值-1,
     //也知道只有状态值为1,然后再执行该方法,才会返回true,否则其它情况全是返回false
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))//对状态值递减,若有其他线程也在操作,则可通过for的无限循环来保证一定能递减成功 return nextc == 0; } } }

 

  该类重写了AQS的tryAcquireShared(int)和tryReleaseShared(int)两个方法, 

  下面来看看这个CountDownLatch类常用的方法

     2、await()方法

 1   public void await() throws InterruptedException {
 2         sync.acquireSharedInterruptibly(1);
 3     }
 4 
 5 
 6     public final void acquireSharedInterruptibly(int arg)
 7             throws InterruptedException {
 8         if (Thread.interrupted())
 9             throw new InterruptedException();
10         if (tryAcquireShared(arg) < 0)
11             doAcquireSharedInterruptibly(arg);
12     }

 

  在调用await方法时,再用sync去调用AQS的内部方法acquireSharedInterruptibly(因为sync类没重写该方法),会先判断当前线程是否被中断(中断一般是由外部条件引起的),若中断直接抛出异常,否则,获取通过tryAcquireShared方法来判断当前线程是否拥有该共享锁,当值小于0,则拥有,大于0,则不拥有,继续下一步,若有锁,则再执行doAcquireSharedInterruptibly方法,

  

 1   private void doAcquireSharedInterruptibly(int arg)
 2         throws InterruptedException {
 3         final Node node = addWaiter(Node.SHARED);//对当前线程进行一个包装,同时也初始化了等待队列,即head->node->...->tail
 4         boolean failed = true;
 5         try {
 6             for (;;) {
 7                 final Node p = node.predecessor();//获取该node节点的前一个节点,一般首次调用时,该前一个节点就是head节点。
 8                 if (p == head) {
 9                     int r = tryAcquireShared(arg);//再次获取锁的状态,
10                     if (r >= 0) {//若状态值为0,则进入
11                         setHeadAndPropagate(node, r);
12                         p.next = null; // help GC
13                         failed = false;
14                         return;
15                     }
16                 }
 //shouldParakAfterFailedAcquire方法主要是针对node节点的状态进行操作,若为signal,则挂起,若为0或PROPAGATE,则转换成signal,为cancelled,则放弃,寻找前一个不是该状态值的节点
17 if (shouldParkAfterFailedAcquire(p, node) && 18 parkAndCheckInterrupt())//挂起线程 19 throw new InterruptedException(); 20 } 21 } finally { 22 if (failed)//若failed为true,一般是出现了异常,或者线程被中断 23 cancelAcquire(node); 24 } 25 }

 

    从上述分析来看,只有当状态值为0的时候,才会调用setHeadAndPropagate(node,int)方法,否则会无限等待,当前线程也会被挂起,该方法源码如下

 private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; 
        setHead(node);//将node节点设置为头结点,对比前面的doAcquireSharedInterruptibly方法,也就是头结点的下一个节点,且该节点的状态为shared
        //对propagate值,头结点和状态,进行判断
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;//获取node节点的下一个节点
         //对node节点的下一个节点进行判断,是否为null,和状态值是否为shared
            if (s == null || s.isShared())
          //该方法作用为了释放当前锁,即线程阻塞
                doReleaseShared();
        }
    }

 

    上面说的是执行await方法后,发生的一系列操作,也知道了只有当状态值为0,才会使线程通行,下面来看一看怎么使状态值为0的。

  3、countDown方法

    在调用tryReleaseShared方法,每调用一次,state值就会减一,但除了某个时刻当state值减一后恰好为0,才会返回true,否则返回false,为0时刻,也表明锁被其它线程给释放了。

 1 public void countDown() {
 2         sync.releaseShared(1);
 3     }
 4 
 5 public final boolean releaseShared(int arg) {
 6      //尝试获取锁的状态
 7         if (tryReleaseShared(arg)) {
 8             doReleaseShared();//此时,状态值已经为0,执行doReleasseShared方法,
 9             return true;
10         }
11         return false;
12     }

 

    也许会有人有疑问,说,为什么在执行await方法后的一些类操作中,也执行了doReleaseShared方法,这岂不是要释放两次?

   其实不然,主要是怕doAcquireSharedInterruptibly方法执行后,由于某种原因,当前线程为挂起(即阻塞了),不再执行了,这时只有通过releaseShared方法来唤醒线程,下面看看doReleaseShared方法的实现

  

private void doReleaseShared() {
        /*
         * Ensure that a release propagates, even if there are other
         * in-progress acquires/releases.  This proceeds in the usual
         * way of trying to unparkSuccessor of head if it needs
         * signal. But if it does not, status is set to PROPAGATE to
         * ensure that upon release, propagation continues.
         * Additionally, we must loop in case a new node is added
         * while we are doing this. Also, unlike other uses of
         * unparkSuccessor, we need to know if CAS to reset status
         * fails, if so rechecking.
         */
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {//若头结点状态为signal,则进入,头结点初始化时的状态值为0
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))//若交换失败,则终止此步操作,继续下一轮循环
                        continue;            // loop to recheck cases
                    unparkSuccessor(h);//这是释放锁的关键
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // 若head节点被改变了,则继续循环,否则,跳出循环
                break;
        }
    }

 

  unparkSuccessor(node)分析如下,该方法作用是为了释放node节点的后一个节点中的线程,在这里,node节点就是head节点

private void unparkSuccessor(Node node) {
      
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

       
        Node s = node.next;
      //下一个节点为null或状态值为cancelled,
if (s == null || s.waitStatus > 0) { s = null;
        //由后往前搜索,节点状态值小于或等于0的节点(即状态值不是cancelled值),搜索到的结果一定是最靠近node节点的,且状态值<=0.
        //至于为什么不从前往后搜索,原因不太清楚!!!
for (Node t = tail; t != null && t != node; t = t.prev) if (t.waitStatus <= 0) s = t; } if (s != null) LockSupport.unpark(s.thread);//释放 }

 

 

 

  三、总结 

    countdownLatch在初始化构造函数时,会先将参数设置为状态state值,之后执行await方法后,会进行这一系列的步骤
    1、将shared和当前线程包装成一个node节点,(在第一次调用还会初始化等待队列)在队列中,有这样的队列 head->node,其中node就是被包装成share的节点

    2、之后在doAcquireSharedInterruptibly方法中,执行了shouldParkAfterFailedAcquire和parkAndCheckInterrupt方法, 若顺利,则head节点的状态值会变为signal,并且当前线程会通过执行park方法进行挂起。

      
    3、在方法tryReleaseShared中,会一直操作state值,使之减1,一直到state的值,减为0时,在这之前,当前线程一直会被阻塞。当为0时,会执行doReleaseShared方法 对当前线程执行unparkSuccessor方法,进行放行。

 


 

  以上就是我对countdownLatch类的理解,若有不足之处,还望指正!

 

以上是关于CountDownLatch源码解析的主要内容,如果未能解决你的问题,请参考以下文章

CountDownLatch源码解析

JUC源码解析CountDownLatch

CountDownLatch源码解析

jdk1.8 J.U.C并发源码阅读------CountDownLatch源码解析

jdk1.8 J.U.C并发源码阅读------CountDownLatch源码解析

AQS实现共享锁及CountDownLatch源码解析