Java并发包之CyclicBarrier

CountDownLatch:同步援助,允许一个或多个线程等待其他线程正在执行的一组操作完成。
CyclicBarrier:同步援助,让一组线程都等待对方达到一个共同的障碍点。

CountDownLatch 是计数器, 线程完成一个就记一个, 就像 报数一样, 只不过是递减的.

CyclicBarrier 线程之间会互相等待，每个线程在再到await方法地方都会阻塞，当所有的线程都执行await方法之后，就会释放阻塞

白话文

• await()
  在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。

每个线程都互相等待，当有一个没有调用await的时候，所有的都等待.当所有线程都调用await方法后，就结束等待，之开始执行，当所有方法执行完毕之后，在执行构造中的run

  

   

    

     

    
    

     

      public static void main(String[] args) throws InterruptedException {
     
    
   

    

     

    
    

     

              ExecutorService exec = Executors.newCachedThreadPool();
     
    
   

    

     

    
    

     

              final CyclicBarrier barrier = new CyclicBarrier(4, new Runnable() {
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

                  @Override
     
    
   

    

     

    
    

     
            public void run() {
     
    
   

    

     

    
    

     

                      System.out.println("好了，大家可以去吃饭了……"  );
     
    
   

    

     

    
    

     

                  }
     
    
   

    

     

    
    

     

              });
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              System.out.println("要吃饭，必须所有人都到终点，oK?");
     
    
   

    

     

    
    

     

              System.out.println("不放弃不抛弃！");
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
        for (int i = 0; i < 4; i++) {
     
    
   

    

     

    
    

     

                  exec.execute(new Runnable() {
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

                      @Override
     
    
   

    

     

    
    

     
                public void run() {
     
    
   

    

     

    
    

     

                          System.out
     
    
   

    

     

    
    

     

                                  .println(Thread.currentThread().getName() + ":Go");
     
    
   

    

     

    
    

     
                    try {
     
    
   

    

     

    
    

     

                              Thread.sleep((long) (2000 * Math.random()));
     
    
   

    

     

    
    

     

                          } catch (InterruptedException e1) {
     
    
   

    

     

    
    

     

                              e1.printStackTrace();
     
    
   

    

     

    
    

     

                          }
     
    
   

    

     

    
    

     

                          System.out.println(Thread.currentThread().getName()
     
    
   

    

     

    
    

     

                                  + ":我到终点了");
     
    
   

    

     

    
    

     
                    try {
     
    
   

    

     

    
    

     

      // await()
     
    
   

    

     

    
    

     

      // 在所有参与者都已经在此 barrier 上调用 await 方法之前，将一直等待。
     
    
   

    

     

    
    

     

                              barrier.await();
     
    
   

    

     

    
    

     

                          } catch (InterruptedException e) {
     
    
   

    

     

    
    

     
                        // TODO Auto-generated catch block
     
    
   

    

     

    
    

     

                              e.printStackTrace();
     
    
   

    

     

    
    

     

                          } catch (BrokenBarrierException e) {
     
    
   

    

     

    
    

     
                        // TODO Auto-generated catch block
     
    
   

    

     

    
    

     

                              e.printStackTrace();
     
    
   

    

     

    
    

     

                          }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

                          System.out.println(Thread.currentThread().getName()
     
    
   

    

     

    
    

     

                                  + ":终于可以吃饭啦！");
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

                      }
     
    
   

    

     

    
    

     

                  });
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

              }
     
    
   

    

     

    
    

     

              exec.shutdown();
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
  
 

  
 
 

  

   

    

     

    
    

     

      要吃饭，必须所有人都到终点，oK?
     
    
   

    

     

    
    

     

      不放弃不抛弃！
     
    
   

    

     

    
    

     

      pool-1-thread-1:Go
     
    
   

    

     

    
    

     

      pool-1-thread-2:Go
     
    
   

    

     

    
    

     

      pool-1-thread-3:Go
     
    
   

    

     

    
    

     

      pool-1-thread-4:Go
     
    
   

    

     

    
    

     

      pool-1-thread-1:我到终点了
     
    
   

    

     

    
    

     

      pool-1-thread-3:我到终点了
     
    
   

    

     

    
    

     

      pool-1-thread-4:我到终点了
     
    
   

    

     

    
    

     

      pool-1-thread-2:我到终点了
     
    
   

    

     

    
    

     

      好了，大家可以去吃饭了……
     
    
   

    

     

    
    

     

      pool-1-thread-2:终于可以吃饭啦！
     
    
   

    

     

    
    

     

      pool-1-thread-3:终于可以吃饭啦！
     
    
   

    

     

    
    

     

      pool-1-thread-1:终于可以吃饭啦！
     
    
   

    

     

    
    

     

      pool-1-thread-4:终于可以吃饭啦！
     
    
   

    

     

    
    

     
 
     
    
  
 

  
 
 

文章来源: springlearn.blog.csdn.net，作者：西魏陶渊明，版权归原作者所有，如需转载，请联系作者。

原文链接：springlearn.blog.csdn.net/article/details/102425312