CountDownLatch在多线程程序中的应用

一.CountDownLatch介绍

CountDownLatch是JDK1.5之后引入的，存在于java.util.concurrent包下，能够使一个线程等待其他线程完成动作后再执行。
构造方法：

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

主要方法：

countDown()方法每调用一次，计数器减1

await()方法使当前线程处于阻塞状态，知道计数器值为0

二.CountDownLatch使用

 package com;

 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicInteger;

 /**
  * CountDownLatch测试
  */
 class myThread<T> extends Thread {
     CountDownLatch countDownLatch;
     Map map;
     //构造函数，传入的是Map
     public myThread(CountDownLatch countDownLatch, Map map) {
         this.countDownLatch = countDownLatch;
         this.map = map;
     }
     public void run() {
         map.put(Thread.currentThread().getName(),new Object());
         countDownLatch.countDown();//线程执行一次就countDown计数器减少1
     }
 }

 public class TestThreadAndCollection {
     public static void main(String[] args) throws InterruptedException {
         //表示测试100次
         for (int i = 0; i < 100; i++) {
             test();
         }
     }

     public static  void test() throws InterruptedException {
         CountDownLatch latch = new CountDownLatch(2000);
         //使用HashMap，这是线程不安全的
         Map<String ,Object> hashMap = new HashMap();
         //使用ConcurrentHashMap，线程安全的
         //Map<String ,Object> concurrentHashMap = new ConcurrentHashMap();
         //两个for循环，2000个线程
         for (int i = 0; i < 1000; i++) {
             //多线程HashMap测试
             //myThread mThread = new myThread(latch, hashMap);
             //多线程concurrentHashMap测试
             myThread mThread = new myThread(latch, hashMap);
             mThread.start();
         }
         for (int i = 0; i < 1000; i++) {
             myThread mThread = new myThread(latch, hashMap);
             mThread.start();
         }
         //等待当前所有子线程执行完,这里也就是使main线程处于等待状态，完了后再输出大小
         latch.await();
         //这里是main线程sleep一段时间（1秒），效果同latch.await();
        /* try{
             System.out.println(Thread.currentThread().getName());//当前线程输出的是main
             Thread.sleep(1000);
         }catch(InterruptedException e){
             e.printStackTrace();
         }*/
         //System.out.println(concurrentHashMap.size());
         System.out.println(hashMap.size());
     }
 }

因为多线程下HashMap是不安全的，所以结果：

而ConcurrentHashMap是线程安全的，结果如下图：

ConcurrentHashMap下，如果把CountDownLatch latch = new CountDownLatch(2000);中参数2000改成小于2000的值（1000）那么输出的结果如下：

因为countDown()计数器递减为0的时候，await()方法就不会再阻塞main线程，所以输出语句的执行可能会在所有线程put完成之前，因此结果不是2000