Java concurrency之CountDownLatch原理和示例_动力节点Java学院整理

// 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。
void await()
// 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。
boolean await(long timeout, TimeUnit unit)
// 递减锁存器的计数，如果计数到达零，则释放所有等待的线程。
void countDown()
// 返回当前计数。
long getCount()
// 返回标识此锁存器及其状态的字符串。
String toString()

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

Sync(int count) {
  setState(count);
} 

protected final void setState(long newState) {
  state = newState;
}

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

public final void acquireSharedInterruptibly(long arg)
    throws InterruptedException {
  if (Thread.interrupted())
    throw new InterruptedException();
  if (tryAcquireShared(arg) < 0)
    doAcquireSharedInterruptibly(arg);
}

protected int tryAcquireShared(int acquires) {
  return (getState() == 0) ? 1 : -1;
}

private void doAcquireSharedInterruptibly(long arg)
  throws InterruptedException {
  // 创建"当前线程"的Node节点，且Node中记录的锁是"共享锁"类型；并将该节点添加到CLH队列末尾。
  final Node node = addWaiter(Node.SHARED);
  boolean failed = true;
  try {
    for (;;) {
      // 获取上一个节点。
      // 如果上一节点是CLH队列的表头，则"尝试获取共享锁"。
      final Node p = node.predecessor();
      if (p == head) {
        long r = tryAcquireShared(arg);
        if (r >= 0) {
          setHeadAndPropagate(node, r);
          p.next = null; // help GC
          failed = false;
          return;
        }
      }
      // (上一节点不是CLH队列的表头) 当前线程一直等待，直到获取到共享锁。
      // 如果线程在等待过程中被中断过，则再次中断该线程(还原之前的中断状态)。
      if (shouldParkAfterFailedAcquire(p, node) &&
        parkAndCheckInterrupt())
        throw new InterruptedException();
    }
  } finally {
    if (failed)
      cancelAcquire(node);
  }
}

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

public final boolean releaseShared(int arg) {
  if (tryReleaseShared(arg)) {
    doReleaseShared();
    return true;
  }
  return false;
}

protected boolean tryReleaseShared(int releases) {
  // Decrement count; signal when transition to zero
  for (;;) {
    // 获取“锁计数器”的状态
    int c = getState();
    if (c == 0)
      return false;
    // “锁计数器”-1
    int nextc = c-1;
    // 通过CAS函数进行赋值。
    if (compareAndSetState(c, nextc))
      return nextc == 0;
  }
}

 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.CyclicBarrier;
 public class CountDownLatchTest1 {
   private static int LATCH_SIZE = 5;
   private static CountDownLatch doneSignal;
   public static void main(String[] args) {
     try {
       doneSignal = new CountDownLatch(LATCH_SIZE);
       // 新建5个任务
       for(int i=0; i<LATCH_SIZE; i++)
         new InnerThread().start();
       System.out.println("main await begin.");
       // "主线程"等待线程池中5个任务的完成
       doneSignal.await();
       System.out.println("main await finished.");
     } catch (InterruptedException e) {
       e.printStackTrace();
     }
   }
   static class InnerThread extends Thread{
     public void run() {
       try {
         Thread.sleep(1000);
         System.out.println(Thread.currentThread().getName() + " sleep 1000ms.");
         // 将CountDownLatch的数值减1
         doneSignal.countDown();
       } catch (InterruptedException e) {
         e.printStackTrace();
       }
     }
   }
 }

main await begin.
Thread-0 sleep 1000ms.
Thread-2 sleep 1000ms.
Thread-1 sleep 1000ms.
Thread-4 sleep 1000ms.
Thread-3 sleep 1000ms.
main await finished.