回环栅栏CyclicBarrier

         通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了.

CyclicBarrier类位于java.util.concurrent包下，CyclicBarrier提供2个构造器：

?

1 2 3 4 5

public CyclicBarrier( int parties, Runnable barrierAction) { }   public CyclicBarrier( int parties) { }

　　参数parties指让多少个线程或者任务等待至barrier状态；参数barrierAction为当这些线程都达到barrier状态时会执行的内容。

　　然后CyclicBarrier中最重要的方法就是await方法，它有2个重载版本：

?

1 2	public int await() throws InterruptedException, BrokenBarrierException { }; public int await( long timeout, TimeUnit unit) throws InterruptedException,BrokenBarrierException,TimeoutException { };

 　　第一个版本比较常用，用来挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务；

　　第二个版本是让这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务。

　　下面举几个例子就明白了：

　　假若有若干个线程都要进行写数据操作，并且只有所有线程都完成写数据操作之后，这些线程才能继续做后面的事情，此时就可以利用CyclicBarrier了：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

public class Test {      public static void main(String[] args) {          int N = 4 ;          CyclicBarrier barrier  = new CyclicBarrier(N);          for ( int i= 0 ;i<N;i++)              new Writer(barrier).start();      }      static class Writer extends Thread{          private CyclicBarrier cyclicBarrier;          public Writer(CyclicBarrier cyclicBarrier) {              this .cyclicBarrier = cyclicBarrier;          }            @Override          public void run() {              System.out.println( "线程" +Thread.currentThread().getName()+ "正在写入数据..." );              try {                  Thread.sleep( 5000 );      //以睡眠来模拟写入数据操作                  System.out.println( "线程" +Thread.currentThread().getName()+ "写入数据完毕，等待其他线程写入完毕" );                            //线程在这里等待，直到所有线程都到达barrier                  cyclicBarrier.await();              } catch (InterruptedException e) {                  e.printStackTrace();              } catch (BrokenBarrierException e){                  e.printStackTrace();              }              System.out.println( "所有线程写入完毕，继续处理其他任务..." );          }      } }

 　　执行结果：

线程Thread-0正在写入数据...
线程Thread-3正在写入数据...
线程Thread-2正在写入数据...
线程Thread-1正在写入数据...
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-0写入数据完毕，等待其他线程写入完毕 线程Thread-3写入数据完毕，等待其他线程写入完毕 线程Thread-1写入数据完毕，等待其他线程写入完毕 所有线程写入完毕，继续处理其他任务... 所有线程写入完毕，继续处理其他任务... 所有线程写入完毕，继续处理其他任务... 所有线程写入完毕，继续处理其他任务...

View Code

　　从上面输出结果可以看出，每个写入线程执行完写数据操作之后，就在等待其他线程写入操作完毕。

　　当所有线程线程写入操作完毕之后，所有线程就继续进行后续的操作了。

　　如果说想在所有线程写入操作完之后，进行额外的其他操作可以为CyclicBarrier提供Runnable参数：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

public class Test {      public static void main(String[] args) {          int N = 4 ;          CyclicBarrier barrier  = new CyclicBarrier(N, new Runnable() {              @Override              public void run() {                            //当所有线程到达barrier时执行                  System.out.println( "当前线程" +Thread.currentThread().getName());                 }          });                    for ( int i= 0 ;i<N;i++)              new Writer(barrier).start();      }      static class Writer extends Thread{          private CyclicBarrier cyclicBarrier;          public Writer(CyclicBarrier cyclicBarrier) {              this .cyclicBarrier = cyclicBarrier;          }            @Override          public void run() {              System.out.println( "线程" +Thread.currentThread().getName()+ "正在写入数据..." );              try {                  Thread.sleep( 5000 );      //以睡眠来模拟写入数据操作                  System.out.println( "线程" +Thread.currentThread().getName()+ "写入数据完毕，等待其他线程写入完毕" );                             //线程在这里等待，直到所有线程都到达barrier。                  cyclicBarrier.await();              } catch (InterruptedException e) {                  e.printStackTrace();              } catch (BrokenBarrierException e){                  e.printStackTrace();              }              System.out.println( "所有线程写入完毕，继续处理其他任务..." );          }      } }

 　　运行结果：

线程Thread-0正在写入数据...
线程Thread-1正在写入数据...
线程Thread-2正在写入数据...
线程Thread-3正在写入数据...
线程Thread-0写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕 线程Thread-2写入数据完毕，等待其他线程写入完毕 线程Thread-3写入数据完毕，等待其他线程写入完毕 当前线程Thread-3 所有线程写入完毕，继续处理其他任务... 所有线程写入完毕，继续处理其他任务... 所有线程写入完毕，继续处理其他任务... 所有线程写入完毕，继续处理其他任务...

View Code

　　从结果可以看出，当四个线程都到达barrier状态后，会从四个线程中选择一个线程去执行Runnable。

 　　下面看一下为await指定时间的效果：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

public class Test {      public static void main(String[] args) {          int N = 4 ;          CyclicBarrier barrier  = new CyclicBarrier(N);                    for ( int i= 0 ;i<N;i++) {              if (i<N- 1 )                  new Writer(barrier).start();              else {                  try {                      Thread.sleep( 5000 );                  } catch (InterruptedException e) {                      e.printStackTrace();                  }                  new Writer(barrier).start();              }          }      }      static class Writer extends Thread{          private CyclicBarrier cyclicBarrier;          public Writer(CyclicBarrier cyclicBarrier) {              this .cyclicBarrier = cyclicBarrier;          }            @Override          public void run() {              System.out.println( "线程" +Thread.currentThread().getName()+ "正在写入数据..." );              try {                  Thread.sleep( 5000 );      //以睡眠来模拟写入数据操作                  System.out.println( "线程" +Thread.currentThread().getName()+ "写入数据完毕，等待其他线程写入完毕" );                  try {                      cyclicBarrier.await( 2000 , TimeUnit.MILLISECONDS);                  } catch (TimeoutException e) {                      // TODO Auto-generated catch block                      e.printStackTrace();                  }              } catch (InterruptedException e) {                  e.printStackTrace();              } catch (BrokenBarrierException e){                  e.printStackTrace();              }              System.out.println(Thread.currentThread().getName()+ "所有线程写入完毕，继续处理其他任务..." );          }      } }

 　　执行结果：

线程Thread-0正在写入数据...
线程Thread-2正在写入数据...
线程Thread-1正在写入数据...
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-0写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕 线程Thread-3正在写入数据... java.util.concurrent.TimeoutException Thread-1所有线程写入完毕，继续处理其他任务... Thread-0所有线程写入完毕，继续处理其他任务... at java.util.concurrent.CyclicBarrier.dowait(Unknown Source) at java.util.concurrent.CyclicBarrier.await(Unknown Source) at com.cxh.test1.Test$Writer.run(Test.java:58) java.util.concurrent.BrokenBarrierException at java.util.concurrent.CyclicBarrier.dowait(Unknown Source) at java.util.concurrent.CyclicBarrier.await(Unknown Source) at com.cxh.test1.Test$Writer.run(Test.java:58) java.util.concurrent.BrokenBarrierException at java.util.concurrent.CyclicBarrier.dowait(Unknown Source) at java.util.concurrent.CyclicBarrier.await(Unknown Source) at com.cxh.test1.Test$Writer.run(Test.java:58) Thread-2所有线程写入完毕，继续处理其他任务... java.util.concurrent.BrokenBarrierException 线程Thread-3写入数据完毕，等待其他线程写入完毕 at java.util.concurrent.CyclicBarrier.dowait(Unknown Source) at java.util.concurrent.CyclicBarrier.await(Unknown Source) at com.cxh.test1.Test$Writer.run(Test.java:58) Thread-3所有线程写入完毕，继续处理其他任务...

View Code

　　上面的代码在main方法的for循环中，故意让最后一个线程启动延迟，因为在前面三个线程都达到barrier之后，等待了指定的时间发现第四个线程还没有达到barrier，就抛出异常并继续执行后面的任务。

　　另外CyclicBarrier是可以重用的，看下面这个例子：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

public class Test {      public static void main(String[] args) {          int N = 4 ;          CyclicBarrier barrier  = new CyclicBarrier(N);                    for ( int i= 0 ;i<N;i++) {              new Writer(barrier).start();          }                    try {              Thread.sleep( 25000 );          } catch (InterruptedException e) {              e.printStackTrace();          }                    System.out.println( "CyclicBarrier重用" );                    for ( int i= 0 ;i<N;i++) {              new Writer(barrier).start();          }      }      static class Writer extends Thread{          private CyclicBarrier cyclicBarrier;          public Writer(CyclicBarrier cyclicBarrier) {              this .cyclicBarrier = cyclicBarrier;          }            @Override          public void run() {              System.out.println( "线程" +Thread.currentThread().getName()+ "正在写入数据..." );              try {                  Thread.sleep( 5000 );      //以睡眠来模拟写入数据操作                  System.out.println( "线程" +Thread.currentThread().getName()+ "写入数据完毕，等待其他线程写入完毕" );                                cyclicBarrier.await();              } catch (InterruptedException e) {                  e.printStackTrace();              } catch (BrokenBarrierException e){                  e.printStackTrace();              }              System.out.println(Thread.currentThread().getName()+ "所有线程写入完毕，继续处理其他任务..." );          }      } }

 　　执行结果：

线程Thread-0正在写入数据...
线程Thread-1正在写入数据...
线程Thread-3正在写入数据...
线程Thread-2正在写入数据...
线程Thread-1写入数据完毕，等待其他线程写入完毕
线程Thread-3写入数据完毕，等待其他线程写入完毕 线程Thread-2写入数据完毕，等待其他线程写入完毕 线程Thread-0写入数据完毕，等待其他线程写入完毕 Thread-0所有线程写入完毕，继续处理其他任务... Thread-3所有线程写入完毕，继续处理其他任务... Thread-1所有线程写入完毕，继续处理其他任务... Thread-2所有线程写入完毕，继续处理其他任务... CyclicBarrier重用 线程Thread-4正在写入数据... 线程Thread-5正在写入数据... 线程Thread-6正在写入数据... 线程Thread-7正在写入数据... 线程Thread-7写入数据完毕，等待其他线程写入完毕 线程Thread-5写入数据完毕，等待其他线程写入完毕 线程Thread-6写入数据完毕，等待其他线程写入完毕 线程Thread-4写入数据完毕，等待其他线程写入完毕 Thread-4所有线程写入完毕，继续处理其他任务... Thread-5所有线程写入完毕，继续处理其他任务... Thread-6所有线程写入完毕，继续处理其他任务... Thread-7所有线程写入完毕，继续处理其他任务...

View Code

　　从执行结果可以看出，在初次的4个线程越过barrier状态后，又可以用来进行新一轮的使用。而CountDownLatch无法进行重复使用。

1.  CyclicBarrier初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时，所有进入等待状态的线程被唤醒并继续。 
2.  CyclicBarrier就象它名字的意思一样，可看成是个障碍， 所有的线程必须到齐后才能一起通过这个障碍。 
3.  CyclicBarrier初始时还可带一个Runnable的参数， 此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。

其它论述请参考：http://wiki.jikexueyuan.com/project/java-concurrency/cyclicbarrier.html