CountDownLatch

CountDownLatch是什么

CountDownLatch 是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。

CountDownLatch 是在java1.5被引入的，存在于java.util.concurrent包下。

CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

CountDownLatch如何工作

构造器中的计数值（count）实际上就是闭锁需要等待的线程数量。这个值只能被设置一次，而且CountDownLatch没有提供任何机制去重新设置这个计数值。主线程必须在启动其他线程后立即调用CountDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。

其他线程必须引用闭锁对象，因为需要通知CountDownLatch对象，已经完成了各自的任务。这种通知机制是通过 CountDownLatch.countDown()方法来完成的；每调用一次这个方法，在构造函数中初始化的count值就减1。所以当所有线程都调 用了这个方法，count的值等于0，然后主线程就能通过await()方法，恢复执行自己的任务。

1.  
public class CountDownLatchDemo {    
    final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");    
    public static void main(String[] args) throws InterruptedException {    
        CountDownLatch latch=new CountDownLatch(2);//两个工人的协作    
        Worker worker1=new Worker("ZhangSan", 5000, latch);    
        Worker worker2=new Worker("LiSi", 8000, latch);    
        worker1.start();//    
        worker2.start();//    
        latch.await();//等待所有工人完成工作    
        System.out.println("all work done at "+sdf.format(new Date()));  
    }   
        
    static class Worker extends Thread{  
        String workerName;     
        int workTime;    
        CountDownLatch latch;    
        public Worker(String workerName ,int workTime ,CountDownLatch latch){    
             this.workerName=workerName;    
             this.workTime=workTime;    
             this.latch=latch;    
        }    
        public void run(){    
            System.out.println("Worker "+workerName+" do work begin at "+sdf.format(new Date()));    
            doWork();//工作了    
            System.out.println("Worker "+workerName+" do work complete at "+sdf.format(new Date()));    
            latch.countDown();//工人完成工作，计数器减一    
        }    
        private void doWork(){    
            try {    
                Thread.sleep(workTime);    
            } catch (InterruptedException e) {    
                e.printStackTrace();    
            }    
        }    
    }       
         
}    
  
2.  
public class CountDownLatchDemo extends Thread {  
    public static CountDownLatch startGate = new CountDownLatch(1);  
    public static CountDownLatch endGate = new CountDownLatch(2000);  
    private String name;  
    public CountDownLatchDemo(String name) {  
        this.name = name;  
    }  
  
    public void run() {  
        try {  
            startGate.await();  
            System.out.println(Thread.currentThread().getName() + "=" + name);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        } finally {  
            endGate.countDown();  
        }  
    }  
  
    public static void main(String[] args) throws InterruptedException {  
        for (int i = 0; i < 2000; i++) {  
            CountDownLatchDemo td = new CountDownLatchDemo(String.valueOf(i));  
            td.start();  
        }  
        long start = System.nanoTime();  
        CountDownLatchDemo.startGate.countDown();  
        CountDownLatchDemo.endGate.await();  
        long end = System.nanoTime();  
        System.out.println("time is " + String.valueOf(end - start));  
    }  
}  

　　

CountDownLatch如何工作

闭锁是一种线程同步的方法，作用是：闭锁关闭期间，不允许特定的进程进行执行，在闭锁打开之后，在闭锁范围内的进程都将执行。

通俗的讲就是，一个闭锁相当于一扇大门，在大门打开之前所有线程都被阻断，一旦大门打开所有线程都将通过，但是一旦大门打开，所有线程都通过了，那么这个闭锁的状态就失效了，门的状态也就不能变了，只能是打开状态。也就是说闭锁的状态是一次性的.

CountDownLatch是闭锁的一个实现

闭锁类：countDownLatch

主要方法为：countDown()、await()

在实时系统中的使用场景

实现最大的并行性：同时启动多个线程，实现最大程度的并行性。

开始执行前等待n个线程完成各自任务：例如应用程序启动类要确保在处理用户请求前，所有N个外部系统已经启动和运行了。

相关引用博客

http://www.importnew.com/15731.html

http://blog.csdn.net/wjbtian/article/details/22655835

http://www.iteye.com/topic/1002652

常见面试题

解释一下CountDownLatch概念?

CountDownLatch 和CyclicBarrier的不同之处?

给出一些CountDownLatch使用的例子?

 CountDownLatch 类中主要的方法?