CountDownLatch实际应用场景

来源：互联网发布：淘宝三福毛衣链编辑：程序博客网时间：2024/06/04 17:44

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

0 0