CountDownLatch 原理

一、CountDownLatch 原理

1、CountDownLatch在多线程并发编程中充当一个计时器的功能，并且内部维护一个count的变量，并且其操作都是原子操作，该类主要通过countDown()和await()两个方法实现功能的，首先通过建立CountDownLatch对象，并且传入参数即为count初始值。

2、如果一个线程调用了await()方法，那么这个线程便进入阻塞状态，并进入阻塞队列。如果一个线程调用了countDown()方法，则会使count-1；当count的值为0时，这时候阻塞队列中调用await()方法的线程便会逐个被唤醒，从而进入后续的操作。比如下面的例子就是有两个操作，一个是读操作一个是写操作，现在规定必须进行完写操作才能进行读操作。所以当最开始调用读操作时，需要用await()方法使其阻塞，当写操作结束时，则需要使count等于0。因此count的初始值可以定为写操作的记录数，这样便可以使得进行完写操作，然后进行读操作。

二、构造方法：CountDownLatch

内部也是有个Sync类继承了AQS，所以CountDownLatch类的构造方法就是调用Sync类的构造方法，然后调用setState()方法设置AQS中state的值

三、方法：countDown()

这个方法会对state值减1，会调用到AQS中releaseShared()方法，目的是为了调用doReleaseShared()方法，这个是AQS定义好的释放资源的方法，而tryReleaseShared()则是子类实现的，可以看到是一个自旋CAS操作，每次都获取state值，如果为0则直接返回，否则就执行减1的操作，失败了就重试，如果减完后值为0就表示要释放所有阻塞住的线程了，也就会执行到AQS中的doReleaseShared()方法

1、线程进入 countDown() 完成计数器减一（释放锁）的操作

      public void countDown() {
          sync.releaseShared(1);
      }

      public final boolean releaseShared(int arg) {
          // 尝试释放共享锁
          if (tryReleaseShared(arg)) {
              // 释放锁成功开始唤醒阻塞节点
              doReleaseShared();
              return true;
          }
          return false;
      }

2、更新 state 值，每调用一次，state 值减一，当 state -1 正好为 0 时，返回 true

      protected boolean tryReleaseShared(int releases) {
          for (;;) {
              int c = getState();
              // 条件成立说明前面【已经有线程触发唤醒操作】了，这里返回 false
              if (c == 0)
                  return false;
              // 计数器减一
              int nextc = c-1;
              if (compareAndSetState(c, nextc))
                  // 计数器为 0 时返回 true
                  return nextc == 0;
          }
      }

a、获取当前状态：调用 getState() 获取当前计数器的值。
b、检查计数器是否为零：如果计数器已经为零，则返回 false，表示不需要唤醒等待的线程。
c、减少计数器：将计数器减一，得到新的计数器值 nextc。
d、CAS 操作：使用 compareAndSetState(c, nextc) 尝试将计数器的值从 c 更新为 nextc。如果成功，则返回 nextc == 0，表示计数器是否减到零。

3、state = 0 时，当前线程需要执行唤醒阻塞节点的任务

   private void doReleaseShared() {
          for (;;) {
              Node h = head;
              // 判断队列是否是空队列
              if (h != null && h != tail) {
                  int ws = h.waitStatus;
                  // 头节点的状态为 signal，说明后继节点没有被唤醒过
                  if (ws == Node.SIGNAL) {
                      // cas 设置头节点的状态为 0，设置失败继续自旋
                      if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                          continue;
                      // 唤醒后继节点
                      unparkSuccessor(h);
                  }
                  // 如果有其他线程已经设置了头节点的状态，重新设置为 PROPAGATE 传播属性
                  else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                      continue;
              }
              // 条件不成立说明被唤醒的节点非常积极，直接将自己设置为了新的head，
              // 此时唤醒它的节点（前驱）执行 h == head 不成立，所以不会跳出循环，会继续唤醒新的 head 节点的后继节点
              if (h == head)
                  break;
          }
   }

小结：当线程使用 countDown() 方法时，其实是使用了 tryReleaseShared() 方法以 CAS 的操作来减少 state ,直至 state 为 0 ，进而释放锁资源，唤醒后续节点。

a、判断队列是否是空队列。
b、检查头节点的状态：如果头节点的状态为 Node.SIGNAL，则表示需要唤醒后续节点。
c、CAS 操作：使用 compareAndSetWaitStatus(h, Node.SIGNAL, 0) 尝试将头节点的状态从 Node.SIGNAL 更新为 0。如果成功，则调用 unparkSuccessor(h) 唤醒后续节点。
d、检查头节点是否变化：如果头节点没有变化，则退出循环。

在开始分析 doReleaseShared() 之前，我们先来补全一下 AQS 中 waitStatus 的状态说明

初始化状态：0，表示当前节点在同步队列中，等待获取锁；
CANCELLED：1，表示当前节点取消获取锁；
SIGNAL：-1，表示后续节点等待当前节点唤醒；
CONDITION：-2，表示当前线程正在条件等待队列中；
PROPAGATE：-3，共享模式，前置节点唤醒后续节点后，唤醒操作无条件传播下去；

四、方法：await()

1、线程调用 await() 等待其他线程完成任务：支持打断

    public void await() throws InterruptedException {
       sync.acquireSharedInterruptibly(1);
    }

2、AbstractQueuedSynchronizer#acquireSharedInterruptibly方法

   public final void acquireSharedInterruptibly(int arg) throws InterruptedException {

            // 判断线程是否被打断，抛出打断异常
            if (Thread.interrupted())
                throw new InterruptedException();

            // 尝试获取共享锁，条件成立说明 state > 0，此时线程入队阻塞等待，等待其他线程获取共享资源
            // 条件不成立说明 state = 0，此时不需要阻塞线程，直接结束函数调用
            if (tryAcquireShared(arg) < 0)
                doAcquireSharedInterruptibly(arg);
  }

a、检查中断状态：首先检查当前线程是否被中断，如果被中断则抛出 InterruptedException。
b、尝试获取共享锁：调用 tryAcquireShared(arg) 方法尝试获取共享锁。在 CountDownLatch 中，tryAcquireShared 的实现是检查计数器是否为零，如果为零则返回 1，否则返回 -1。
c、如果获取锁失败：如果 tryAcquireShared 返回 -1，表示当前计数器不为零，调用 doAcquireSharedInterruptibly(arg) 方法将当前线程加入等待队列并阻塞。

3、线程进入 AbstractQueuedSynchronizer#doAcquireSharedInterruptibly 函数阻塞挂起，等待 latch 变为 0：

   private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {

            // 将调用latch.await()方法的线程 包装成 SHARED 类型的 node 加入到 AQS 的阻塞队列中
            final Node node = addWaiter(Node.SHARED);

            boolean failed = true;

            try {
                for (;;) {
                    // 获取当前节点的前驱节点
                    final Node p = node.predecessor();
                    // 前驱节点时头节点就可以尝试获取锁
                    if (p == head) {
                        // 再次尝试获取锁，获取成功返回 1
                        int r = tryAcquireShared(arg);
                        if (r >= 0) {
                            // 获取锁成功，设置当前节点为 head 节点，并且向后传播
                            setHeadAndPropagate(node, r);
                            p.next = null; // 到了这步时p节点会被删除
                            failed = false;
                            return;
                        }
                    }
                    // parkAndCheckInterrupt阻塞在这里
                    if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                        throw new InterruptedException();
                }
            } finally {
                // 阻塞线程被中断后抛出异常，进入取消节点的逻辑
                if (failed)
                    cancelAcquire(node);
            }
  }

a、将当前线程加入等待队列：调用 addWaiter(Node.SHARED) 将当前线程包装成一个 Node 节点并加入等待队列。哨兵节点--->Node节点
b、自旋等待：在一个无限循环中，检查当前节点的前驱节点是否是头节点。如果是头节点，则尝试获取共享锁。
c、获取锁成功：如果 tryAcquireShared(arg) 返回大于等于 0 的值，表示获取锁成功，调用 setHeadAndPropagate(node, r) 设置头节点并唤醒后续的共享节点。
d、检查是否需要阻塞：如果获取锁失败，调用 shouldParkAfterFailedAcquire(p, node) 检查是否需要阻塞当前线程。如果需要阻塞，则调用 parkAndCheckInterrupt() 阻塞当前线程并检查中断状态。
e、处理中断：如果在阻塞过程中线程被中断，则抛出 InterruptedException。

4、获取共享锁成功，进入唤醒阻塞队列中与头节点相连的 SHARED 模式的节点：

   private void setHeadAndPropagate(Node node, int propagate) {

          Node h = head;

          // 将当前节点设置为新的 head 节点，前驱节点和持有线程置为 null
          setHead(node);

      	  // propagate = 1，条件一成立
          if (propagate > 0 || h == null || h.waitStatus < 0 || (h = head) == null || h.waitStatus < 0) {
              // 获取当前节点的后继节点
              Node s = node.next;
              // 当前节点是尾节点时 next 为 null，或者后继节点是 SHARED 共享模式
              if (s == null || s.isShared())
                  // 唤醒所有的等待共享锁的节点
                  doReleaseShared();
          }
  }

a、将当前的头节点 head 赋值给局部变量 h，以便后续检查使用
b、将传入的 node 设置为新的头节点 head
c、这个条件判断包含了多个子条件，用于决定是否进行进一步的操作：
- propagate > 0：如果 propagate 大于 0，说明state已经为0，表示需要传播信号。
- h == null：如果旧的头节点为空，表示链表或队列之前是空的。
- h.waitStatus < 0：如果旧的头节点的状态小于 0，表示该节点可能处于某种特殊状态（例如等待唤醒）。
- (h = head) == null：再次检查新的头节点是否为空。
- h.waitStatus < 0：再次检查新的头节点的状态。
d、当前节点是尾节点时 next 为 null，或者后继节点是 SHARED 共享模式

小结：当线程使用 await() 方法时会将当前线程封装成 node 加入AQS 队列中，如果发现 state 不为0，说明还有任务未执行完成，继续阻塞；如果 state 为0，会释放掉所有的等待线程，执行 await() 之后的数据。

5、doReleaseShared方法，唤醒队列中阻塞节点

  private void doReleaseShared() {

        for (;;) {

            // 此时head已经为传入Node，因为在前面已经重置了
            Node h = head;
            // 判断队列是否是空队列
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                // 头节点的状态为 signal，说明后继节点没有被唤醒过
                if (ws == Node.SIGNAL) {
                    // cas 设置头节点的状态为 0，设置失败继续自旋
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;
                    // 唤醒后继节点
                    unparkSuccessor(h);
                }
                // 如果有其他线程已经设置了头节点的状态，重新设置为 PROPAGATE 传播属性
                else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;
            }
            // 条件不成立说明被唤醒的节点非常积极，直接将自己设置为了新的head，
            // 此时唤醒它的节点（前驱）执行 h == head 不成立，所以不会跳出循环，会继续唤醒新的 head 节点的后继节点
            if (h == head)
                break;
        }
    }

6、进入 shouldParkAfterFailedAcquire 逻辑，将前驱 node 的 waitStatus 改为 -1，返回 false；waitStatus 为 -1 的节点用来唤醒下一个节点

    //该方法的作用是保证上一个节点的waitStatus状态为-1（为了唤醒后继节点）
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {

    	   //获取上一个节点的状态,该状态为-1，才会唤醒下一个节点。
    	   int ws = pred.waitStatus;

    	   // 如果上一个节点的状态是SIGNAL即-1，可以唤醒下一个节点，直接返回true
    	   if (ws == Node.SIGNAL)
    		  return true;

           // 如果上一个节点的状态大于0，说明已经失效了
           if (ws > 0) {
    			 do {
    			 
    				// 将node 的节点与 pred 的前一个节点相关联，并将前一个节点赋值给 pred
    				node.prev = pred = pred.prev;
    			 
    			 } while (pred.waitStatus > 0); // 一直找到小于等于0的
    			
    			 // 将重新标识好的最近的有效节点的 next 指向当前节点
    			 pred.next = node;
    		 
           } else {
    	   
    		  // 小于等于0，但是不等于-1，将上一个有效节点状态修改为-1
              compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
           }
           return false;
     }

a、shouldParkAfterFailedAcquire 执行完毕回到 acquireQueued ，再次 tryAcquire 尝试获取锁，这时 state 仍为 1 获取失败（第四次）
b、当再次进入 shouldParkAfterFailedAcquire 时，这时其前驱 node 的 waitStatus 已经是 -1 了，返回 true
c、进入 parkAndCheckInterrupt， Thread-1 park（灰色表示）

7、parkAndCheckInterrupt() 阻塞当前线程并检查中断状态

   private final boolean parkAndCheckInterrupt() {

        // 阻塞当前线程，如果打断标记已经是 true, 则 park 会失效
        LockSupport.park(this);

        // 判断当前线程是否被打断，清除打断标记
        return Thread.interrupted();
   }

案例：

        import java.util.concurrent.CountDownLatch;
        import java.util.concurrent.Executor;
        import java.util.concurrent.Executors;

        public class CountDownLatchtTest {

            private static final int N = 10; // 乘客数


            public static void main(String[] args) throws InterruptedException {

                //step1：创建倒数闩，设置倒数的总数
                CountDownLatch doneSignal = new CountDownLatch(N);

                Executor e = Executors.newFixedThreadPool(N);

                for (int i = 1; i <= N; ++i) {
                    e.execute(new Person1(doneSignal, i));
                }
                doneSignal.await(); //step2：等待报数完成，倒数闩计数值为0
                System.out.println("人到齐，开车");
            }
        }

      class Person1 implements Runnable{

            private final CountDownLatch doneSignal;

            private final int i;

            Person1(CountDownLatch doneSignal, int i) {
                this.doneSignal = doneSignal;
                this.i = i;
            }

            @Override
            public void run() {
                //报数
                System.out.println("第" + i + "个人已到");
                doneSignal.countDown(); //step3:倒数闩减少1

            }

       }

五、流程图了解一下