public CountDownLatch(int count) {

         if (count < 0) throw new IllegalArgumentException("count < 0");

         this.sync = new Sync(count);

     }

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

     }

 }