在过去我们实现多线程同步的代码中,往往使用join()、wait()、notiyAll()等线程间通信的方式,随着JUC包的不断的完善,java为我们提供了丰富同步工具类,官方也鼓励我们使用工具类来实现多线程的同步,今天我们就对其中CountDownLatch类的使用与底层实现进行分析与总结。
  
  一、CountDownLatch使用
  
  CountDownLatch其实可以看做一个计数器,统计多个线程执行完成的情况,适用于控制一个或多个线程等待,直到所有线程都执行完毕的场景,类似与Thread.join()的作用。下面我们通过一个简单的例子看下CountDownLatch的使用。
  
  复制代码
  
  public static void main(String[] args) {
  
  final CountDownLatch countDownLatch = new CountDownLatch(5);
  
  // 启动计数线程
  
  for (int i = 0; i < 5; i++) {
  
  new CountDownLatchThread(i, countDownLatch).start();
  
  }
  
  // 启动等待线程
  
  for (int i = 0; i < 5; i++) {
  
  new Thread() {
  
  public void run() {
  
  try {
  
  countDownLatch.await(www.bdqxylgw.com );
  
  } catch (InterruptedException e) {
  
  // TODO Auto-generated catch block
  
  e.printStackTrace();
  
  }
  
  System.out.println("计数完毕了," + Thread.currentThread().getName() + "等待线程执行");
  
  }
  
  }.start();
  
  }
  
  }
  
  复制代码
  
  计数线程代码:
  
  复制代码
  
  public class CountDownLatchThread extends Thread {
  
  private CountDownLatch www.rmutk.net countDownLatch;
  
  private int name;
  
  private int count;
  
  public CountDownLatchThread(int name, CountDownLatch countDownLatch) {
  
  this.name = name;
  
  this.countDownLatch =www.chaoyuuyule.com countDownLatch;
  
  this.count = 0;
  
  }
  
  public void run() {
  
  try {
  
  for (int i = 0; i < 10; i++) {
  
  Thread.sleep(100);
  
  count++;
  
  }
  
  System.out.println(name + "号线程--" + Thread.currentThread().getName() + "--计数完成了");
  
  countDownLatch.countDown(www.yaoshiyulegw.com);
  
  } catch (Exception e) {
  
  // TODO Auto-generated catch block
  
  e.printStackTrace(www.yifayuled.cn);
  
  }
  
  }
  
  }
  
  复制代码
  
  输出结果:
  
  复制代码
  
  1号线程--Thread-1--计数完成了
  
  0号线程--Thread-0--计数完成了
  
  4号线程--Thread-4--计数完成了
  
  2号线程--Thread-2--计数完成了
  
  3号线程--Thread-3--计数完成了
  
  计数完毕了,Thread-5等待线程执行
  
  计数完毕了,Thread-6等待线程执行
  
  计数完毕了,Thread-7等待线程执行
  
  计数完毕了,Thread-8等待线程执行
  
  计数完毕了,Thread-9等待线程执行
  
  复制代码
  
  通过上面的例子可以看到,利用CountDownLatch的countDown方法与await()方法,我们可以同步计数线程与等待线程,使等待线程在所有计数线程完成后再开始运行。
  
  二、CountDownLatch源码分析
  
  接下来我们对countDownLatch内部源码进行一下分析。
  
  1、CountDownLatch的构造。
  
  首先看下CountDownLatch的构造函数
  
  public CountDownLatch(int count) {
  
  if (count <www.xcdeyiju.com 0) throw new IllegalArgumentException("count < 0");
  
  this.sync = new Sync(count);
  
  }
  
  CountDownLatch的构造函数会接收一个count值做为计数器,也就是如果你需要等待N个线程执行结束,那这里就传入N。同时CountDownLatch会实例化一个Sync对象,这个Sync其实是CountDownLatch内部定义的一个继承自AbstractQueuedSynchronizer的实现类,所以CountDownLatch提供的同步和其他功能都是围绕Sync这个子类实现的,也就是基于AbstractQueuedSynchronizer类来实现的。
  
  我们来看下Sync这个类的定义
  
  复制代码
  
  private static final class Sync extends AbstractQueuedSynchronizer {
  
  private static final long serialVersionUID = 4982264981922014374L;
  
  /**
  
  1、设置AbstractQueuedSynchronizer中同步状态的值state,也就是计数器的值。
  
  2、这个值volatile变量,必须保证线程间的可见性;
  
  **/
  
  Sync(int count) {
  
  setState(count);
  
  }
  
  int getCount() {
  
  return getState();
  
  }
  
  //获取同步状态的值
  
  protected int tryAcquireShared(int acquires) {
  
  return (getState() == 0) ? 1 : -1;
  
  }
  
  protected boolean tryReleaseShared(int releases) {
  
  // 通过CAS操作改变同步状态值,保证同步状态的值state的线程安全。
  
  for (;;) {
  
  int c = getState();
  
  if (c == 0)
  
  return false;
  
  int nextc = c-1;
  
  if (compareAndSetState(c, nextc))
  
  return nextc == 0;
  
  }
  
  }
  
  }
  
  复制代码
  
  2、countDown方法
  
  首先我们看下countDown方法的源码
  
  public void countDown() {
  
  //改变同步状态值,线程执行完成时计数器减一
  
  sync.releaseShared(1);
  
  }
  
  AbstractQueuedSynchronizer类中releaseShared() 方法的源码
  
  复制代码
  
  public final boolean releaseShared(int arg) {
  
  // CountDownLatch定义的子类Sync实现,通过CAS操作改变State的值
  
  if (tryReleaseShared(arg)) {
  
  //State以递减为0,代表着所有执行线程执行完毕,共享模式下释放锁,那么等待线程就能够拿到锁往下执行。
  
  doReleaseShared();
  
  return true;
  
  }
  
  return false;
  
  }
  
  复制代码
  
  当调用CountDownLatch的countDown方法时,就会执行计数器进行减一操作,直到所有线程全部执行完毕,计算器为0时唤醒等待线程。
  
  AbstractQueuedSynchronizer中doReleaseShared方法是执行共享模式下释放锁的操作,从而让等待线程获取锁,继续向下执行。
  
  3、await方法
  
  public void await() throws InterruptedException {
  
  sync.acquireSharedInterruptibly(1);
  
  }
  
  AbstractQueuedSynchronizer类中acquireSharedInterruptibly() 方法的源码
  
  复制代码
  
  public final void acquireSharedInterruptibly(int arg)
  
  throws InterruptedException {
  
  if (Thread.interrupted())
  
  throw new InterruptedException();
  
  //获取同步状态值
  
  if (tryAcquireShared(arg) < 0)
  
  //同步状态值即计数器的值不为0,等待线程共享模式下尝试获取锁,获取不到锁的话进入阻塞
  
  doAcquireSharedInterruptibly(arg);
  
  }
  
  复制代码
  
  await方法的实现也很明确,首页获取同步状态也就是计数器的值,如果为0即所有线程执行完毕返回1,否则返回-1的话,等待线程在共享模式下尝试获取锁,获取不到锁的话进入阻塞;
  
  AbstractQueuedSynchronizer中doAcquireSharedInterruptibly方法是执行共享模式下获取锁的操作;
  
  三、总结
  
  通过上面分析可以看到CountDownLatch是基于AbstractQueuedSynchronizer类实现的,一个非常实用的多线程控制工具类,它类似与一个计数器用来控制指定的线程等待,直到计数器归零。以上我们对CountDownLatch类的使用与核心方法的源码进入了一定的分析,其中如有不足与不正确的地方还望指出与海涵。

06-29 03:48