带你快速搞定java多线程(5)

1、介绍

CountDownLantch 倒数计时器，一个同步辅助类，一个线程（或者多个），等待另外N个线程完成某个事情后才能执行。用给定的计数初始化CountDownLatch，其含义是要被等待执行完的线程个数。

每次调用CountDown()，计数减1，执行到await()函数会阻塞等待线程的执行，直到计数为0。

CountDownLantch 无法重置

2、countdownlantch的用法。

举个例子

场景：模拟10人赛跑。喊完“Game Start”才开始跑，10人跑完后才喊"Game Over."，代码如下：

				?

									import java.util.concurrent.CountDownLatch;

									import java.util.concurrent.ExecutorService;

									import java.util.concurrent.Executors;

									/**

									* CountDownLatchTest

									* @author 香菜

									*/

									public class CountDownLatchTest {

									   private static final int RUNNER_COUNT = 10;

									   private static final int CORE_THREAD_COUNT = 10;

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

									       final CountDownLatch begin = new CountDownLatch(1);

									       final CountDownLatch end = new CountDownLatch(RUNNER_COUNT);

									       final ExecutorService exec = Executors.newFixedThreadPool(CORE_THREAD_COUNT);

									       // 启动是个线程

									       for (int i = 0; i < RUNNER_COUNT; i++) {

									           final int NO = i + 1;

									           Runnable run = () -> {

									               try {

									                   // 主线程 begin 之后所有的线程才会开始运行

									                   begin.await();

									                   Thread.sleep((long)(Math.random() * 10000));

									                   System.out.println("No." + NO + " arrived");

									              } catch (InterruptedException e) {

									                   e.printStackTrace();

									              } finally {

									                   // 当前线程结束

									                   end.countDown();

									              }

									          };

									           exec.submit(run);

									      }

									       System.out.println("Game Start ...");

									       begin.countDown();

									       // 等待其他的线程结束

									       end.await();

									       System.out.println("Game Over.");

									       exec.shutdown();

									  }

									}

带你快速搞定java多线程(5)

3、如何利用AQS 实现 CountDownLatch

带你快速搞定java多线程(5)

void await():如果当前count大于0,当前线程将会wait,直到count等于0或者中断。
boolean await(long timeout, TimeUnit unit)：使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。
void countDown()：递减锁存器的计数，如果计数到达零，则释放所有等待的线程。 long getCount() ：获得计数的数量

通过代码可见，CountDownLatch 的核心实现是内部类 Sync，Sync 继承自 AbstractQueuedSynchronizer，让我们打开Sync 一探究竟。

				?

									private static final class Sync extends AbstractQueuedSynchronizer {

									      private static final long serialVersionUID = 4982264981922014374L;

									      Sync(int count) {

									          setState(count);

									      }

									      int getCount() {

									          return getState();

									      }

									      protected int tryAcquireShared(int acquires) {

									          return (getState() == 0) ? 1 : -1;

									      }

									      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))

									                  return nextc == 0;

									          }

									      }

									  }