CountDownLatch多线程使用

简介：

     Java在JDK1.5之后引入了CountDownLatch类。这个类是一个同步辅助类。用于一个线程等待多个操作完成之后再执行，也就是这个当前线程会一直阻塞，直到它所等待的多个操作已经完成。

方法介绍：

1.     await方法，需要等到其他操作先完成的那个线程调用的，先将线程休眠，直到其他操作完成，计数器减为0，才会唤醒因此休眠的线程
2. countDown方法，每个被等待的事件在完成之后调用，会将计数器减一

使用实例：

1.     某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为n new CountDownLatch(n) ，每当一个任务线程执行完毕，就将计数器减1 countdownlatch.countDown()，当计数器的值变为0时，在CountDownLatch上 await() 的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

   public class TestCountDownLatch
   {
       public static void main(String[] args)
       {
           try
           {
               //定义线程数量为4
               CountDownLatch count = new CountDownLatch(4);
               new Thread(new TopTask(count)).start();     //启动线程
               new Thread(new MainTask(count)).start();    //启动线程
               new Thread(new LeftTask(count)).start();    //启动线程
               new Thread(new RightTask(count)).start();   //启动线程
               //主线程等待
               count.await();
               System.out.println(Thread.currentThread().getName()+"线程加载完毕执行主线程...............");
           }
           catch (InterruptedException e)
           {
               e.printStackTrace();
           }
       }
   
   }
   
   
   
   class TopTask implements Runnable{
       
       private CountDownLatch count;
       
       public TopTask(CountDownLatch count)
       {
           this.count = count;
       }
       
       @Override
       public void run()
       {   
           System.out.println(Thread.currentThread().getName()+"线程加载top...............");
           count.countDown();
       }
   }
   
   
   class MainTask implements Runnable{
   
       private CountDownLatch count;
       
       public MainTask(CountDownLatch count)
       {
           this.count = count;
       }
       
       @Override
       public void run()
       {   
           System.out.println(Thread.currentThread().getName()+"线程加载main...............");
           count.countDown();
       }
   }
   
   
   class LeftTask implements Runnable{
   
       private CountDownLatch count;
       
       public LeftTask(CountDownLatch count)
       {
           this.count = count;
       }
       
       @Override
       public void run()
       {   
           System.out.println(Thread.currentThread().getName()+"线程加载left...............");
           count.countDown();
       }
   }
   
   class RightTask implements Runnable{
   
       private CountDownLatch count;
       
       public RightTask(CountDownLatch count)
       {
           this.count = count;
       }
       
       @Override
       public void run()
       {   
           System.out.println(Thread.currentThread().getName()+"线程加载right...............");
           count.countDown();
       }
   }

2. 实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的CountDownLatch(1)，将其计数器初始化为1，多个线程在开始执行任务前首先 coundownlatch.await()，当主线程调用 countDown() 时，计数器变为0，多个线程同时被唤醒。

   public class TestCountDownLatch1
   {
       public static void main(String[] args) throws InterruptedException
       {
           CountDownLatch startCount = new CountDownLatch(1);
           
           for (int i = 0; i < 5; i++ )
           {
               new Thread(new TestThread(startCount)).start();
           }
           System.out.println("多线程开始并行执行......");
           //主线程变为0，多个线程被同时唤醒
           startCount.countDown();
       }
   }
   
   
   class TestThread implements Runnable
   {
       private CountDownLatch startCount;
       
       public TestThread(CountDownLatch startCount)
       {
           this.startCount = startCount;
       }
       
       @Override
       public void run()
       { 
           try
           {
               startCount.await();   //线程等待(等待主线程执行信号...)
               System.out.println(Thread.currentThread().getName()+"开始执行自己的业务........");
           }
           catch (InterruptedException e)
           {
               e.printStackTrace();
           }
       }
   }