架构师养成记--12.Concurrent工具类CyclicBarrier和CountDownLatch

java.util.concurrent.CyclicBarrier

一组线程共同等待，直到达到一个公共屏障点。

举个栗子，百米赛跑中，所有运动员都要等其他运动员都准备好后才能一起跑（假如没有发令员）。

 import java.io.IOException;
 import java.util.Random;
 import java.util.concurrent.BrokenBarrierException;
 import java.util.concurrent.CyclicBarrier;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 public class UseCyclicBarrier {

     static class Runner implements Runnable {  //远动员，每个运动员都是一个单独的线程
         private CyclicBarrier barrier;  //屏障点
         private String name;  

         public Runner(CyclicBarrier barrier, String name) {
             this.barrier = barrier;  //每个运动员都要有这个屏障点信息（在这里就表现为：所有人都准备好）
             this.name = name;
         }
         @Override
         public void run() {
             try {
                 Thread.sleep(1000 * (new Random()).nextInt(5));  //假设每个运动员都要准备一段时间
                 System.out.println(name + " 准备OK.");
                 barrier.await();  //准备好了就等待，等其他人都准备好了
             } catch (InterruptedException e) {
                 e.printStackTrace();
             } catch (BrokenBarrierException e) {
                 e.printStackTrace();
             }
             System.out.println(name + " Go!!");  //其他人都准备好了，跑！
         }
     } 

     public static void main(String[] args) throws IOException, InterruptedException {
         CyclicBarrier barrier = new CyclicBarrier(3);  // 3
         ExecutorService executor = Executors.newFixedThreadPool(3);  

         executor.submit(new Thread(new Runner(barrier, "zhangsan")));  //zhangsan准备并等待
         executor.submit(new Thread(new Runner(barrier, "lisi")));      //lisi准备并等待
         executor.submit(new Thread(new Runner(barrier, "wangwu")));    //wangwu准备并等待

         executor.shutdown();
     }  

 }  

执行结果：

java.util.Concurrent.CountDownLatch

t1线程要等待t2和t3线程都准备好了才继续往下执行。

还是举个栗子，上面的那个栗子中，安排一个发令员，发令员走向场边，下面他应该打响发令枪，但是在这之前，他要确认其他人都准备好了，假设这里的跑步规则是发令员听到所有人都报完名字后才确认所有人都准备好了。

 import java.util.concurrent.CountDownLatch;

 public class UseCountDownLatch {

     public static void main(String[] args) {

         final CountDownLatch countDown = new CountDownLatch(2);

         Thread t1 = new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     System.out.println("进入线程t1" + "等待其他线程处理完成...");
                     countDown.await();//计数，计数达到2后继续执行
                     System.out.println("t1线程继续执行...");
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         },"t1");

         Thread t2 = new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     System.out.println("t2线程进行初始化操作...");
                     Thread.sleep(3000);
                     System.out.println("t2线程初始化完毕，通知t1线程继续...");
                     countDown.countDown();//报数
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         });
         Thread t3 = new Thread(new Runnable() {
             @Override
             public void run() {
                 try {
                     System.out.println("t3线程进行初始化操作...");
                     Thread.sleep(4000);
                     System.out.println("t3线程初始化完毕，通知t1线程继续...");
                     countDown.countDown();//报数
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         });

         t1.start();
         t2.start();
         t3.start();

     }
 }

执行结果：