CountDownLatch实际应用场景

CountDownLatch类是java 1.5版本的并发包下的类

具体的使用场景：

1.当一个问题被分为多个部分，只有在所有子任务全部执行完后，在可以去执行其他的任务。

代码如下：

/**
 *
 * @author madongxu
 *CountDownLatch:
 *应用场景：
 *1.将一个问题，分割成多个部分，当所有的子部分任务全部执行完毕后，才去执行其他的任务。
 */
public class CountDownLatchDemo2 {

    private static final int N=3;
    void main()throws InterruptedException{
        //定义，线程同步等待对象
        CountDownLatch doneSignal = new CountDownLatch(N);
        //定义一个线程池，执行线程任务
        Executor executor = Executors.newFixedThreadPool(3);
        for(int i =0;i             executor.execute(new WorkerRunnable(doneSignal,i));
        }
        //等待其他所有线程执行完，才去执行主线程的任务
        doneSignal.await();
        System.out.println("主线程执行");
    }
    
    class WorkerRunnable implements Runnable {
           private final CountDownLatch doneSignal;
           private final int i;
           WorkerRunnable(CountDownLatch doneSignal, int i) {
              this.doneSignal = doneSignal;
              this.i = i;
           }
           public void run() {
              try {
                doWork(i);
                doneSignal.countDown();
              } catch (Exception e) {
                  
              } // return;
           }

           void doWork(int i) {
               System.out.println("任务"+i+"执行");
           }
         }
    
    public static void main(String[] args) {
        CountDownLatchDemo2 d = new CountDownLatchDemo2();
        try {
            d.main();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

2.使用2个CountDownLatch对象

1）开始执行任务标识

2）任务执行中的标识

当使用开始任务标识时，可以控制程序在开始线程任务执行前，可以做一些初始化的任务，之后在开始执行任务。

 *CountDownLatch:
 *应用场景：
 *定义2个CountDownLatch对象
 *1）startSingle：使用开始信号，作为控制所有线程的执行开关
 *2）doneSingle：具体线程执行的信号
 *描述：
 *在所有任务执行前，先初始化一系列操作，当初始化完毕后，启动startSingle，开始
 *让其他线程进行执行任务，当所有任务执行完毕后，去执行主线程的任务
 *
 *
 */
public class CountDownLatchDemo1 {

    private static final int N =3;
    void main(){
        //开始
        CountDownLatch startSingle = new CountDownLatch(1);
        //每个线程去执行任务
        CountDownLatch doneSingle= new CountDownLatch(N);
        
        for(int i =0;i             new Thread(new WorkerRunnable(startSingle, doneSingle, i)).start();
        //控制是否开始执行任务
        startSingle.countDown();
        System.out.println("66666");
        try {
            doneSingle.await();
            System.out.println("主线程执行");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
    
    
    class WorkerRunnable implements Runnable{
        CountDownLatch start =null;
        CountDownLatch done = null;
        int num = 0;
        public WorkerRunnable(CountDownLatch startSingle, CountDownLatch doneSingle , int i) {
            this.start=startSingle;
            this.done=doneSingle;
            this.num=i;
        }
        
        @Override
        public void run() {
            try {
                start.await();
                doWork(num);
                done.countDown();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
        
        public void doWork(int i){
            System.out.println("任务"+i+"执行");
        }
        
    
    }
    
    public static void main(String[] args) {
        CountDownLatchDemo1 demo1 = new CountDownLatchDemo1();
        demo1.main();
    }