CyclicBarrier正确的使用方法和错误的使用方法

CyclicBarrier是java推出的一个并发编程工具，它用在多个线程之间协同工作。线程约定到达某个点，到达这个点之后的线程都停下来，直到最后一个线程也到达了这个点之后，所有的线程才会得到释放。常用的场景是：多个worker线程，每个线程都在循环地做一部分工作，并在最后用cyclicBarrier.await()设下约定点，当最后一个线程做完了工作也到达约定点后，所有线程得到释放，开始下一轮工作。也就是下面这样：

 while(!done()){
     //working
     cyclicBarrier.await();
 }

CyclicBarrier还支持一个回调函数，每当一轮工作结束后，下一轮工作开始前，这个回调函数都会被调用一次。

但是，使用CyclicBarrier必须准守最佳实践的使用方法，否则，就可能达不到想要的效果。比如，下面这样，就是一种典型的错误使用方法：

    private void process(CyclicBarrier cyclicBarrier) {
        final int n = 100;
        Runnable worker= new Runnable() {
            @Override
            public void run() {

                    try {
                        //模拟工作
                        Thread.sleep(3000);
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                    try {
                        cyclicBarrier.await();
                    } catch (BrokenBarrierException | InterruptedException ex) {
                        ex.printStackTrace();
                    }
                }
                System.out.println("Worker is done");
                System.out.println("Thread of Worker is "+ Thread.currentThread().getId());

        };

        for (int i = 0; i < n; i++) {
            Thread t1 = new Thread(worker);
            Thread t2 = new Thread(worker);
            t1.start();
            t2.start();
        }

    }

在上面的代码中，工作不在worker线程中循环，而是在开启工作的线程中循环，也就是说，它会不断地开启新的worker线程。这会导致的一个问题是，上一轮的回调还没执行完成，下一轮的工作就已经开始了。

那么为什么呢？下面来分析一下原因。

首先，要知道CyclicBarrier是如何做到在上一轮工作结束后下一轮工作开始前执行回调函数的。查看jdoc文档，里面有这么一句话“A CyclicBarrier supports an optional Runnable command that is run once per barrier point, after the last thread in the party arrives, but before any threads are released. ”这是描述回调函数的，从描述中可以看到，回调函数是在最后一个线程到达约定点后，线程释放前被执行的。也就是说，回调函数的执行时间发生在下一轮工作前，这是通过在执行完回调函数再释放工作线程来实现的。

然后，我们再来看看上面错误的使用方法。在错误的使用方法中，主线程的每一轮循环中都开启了新的worker线程，这样在回调函数结束之前，前面开启的worker线程确实没有得到释放，但是，新开启的工作线程却完全可以执行下一轮工作，这就是为什么在回调函数执行完毕之前，新一轮的工作就已经开始了的原因。并且，错误方法中的每一个工作线程只执行一轮工作就结束了，每一轮工作之间的线程互不影响，这也就失去了协作性，因此，千万要避免写出这种代码。

关于CyclicBarrier使用的最佳时间，基本上就是官方示例中的用法了，如下：

 class Solver {
    final int N;
    final float[][] data;
    final CyclicBarrier barrier;

    class Worker implements Runnable {
      int myRow;
      Worker(int row) { myRow = row; }
      public void run() {
        while (!done()) {
          processRow(myRow);

          try {
            barrier.await();
          } catch (InterruptedException ex) {
            return;
          } catch (BrokenBarrierException ex) {
            return;
          }
        }
      }
    }

    public Solver(float[][] matrix) {
      data = matrix;
      N = matrix.length;
      barrier = new CyclicBarrier(N,
                                  new Runnable() {
                                    public void run() {
                                      mergeRows(...);
                                    }
                                  });
      for (int i = 0; i < N; ++i)
        new Thread(new Worker(i)).start();

      waitUntilDone();
    }
  }

最后在有一个问题是，回调函数是在哪一个线程里执行的？

根据我的demo测试发现，是在第一个到达的线程中执行的。当然，官方并没有明确规定这一点，也许以后会有变化吧，所以，我们也不能以来这一特征。我的demo如下：

public class Demo1 {
　  public static main(String[] args){
        Demo1 demo =  new Demo1();
        demo1.showInfThreadWhenDirectly();
    }
    private void process(CyclicBarrier cyclicBarrier) {
        final int n = 100;
        Runnable worker= new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < n; i++) {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                    try {
                        int arrival_index=cyclicBarrier.await();
                        if(0==arrival_index){
                            System.out.println("first arrival Thread in this iteration is: "
                                    +Thread.currentThread().getId());
                        }
                    } catch (BrokenBarrierException | InterruptedException ex) {
                        ex.printStackTrace();
                    }
                }
                System.out.println("Worker is done");
                System.out.println("Thread of Worker is "+ Thread.currentThread().getId());
            }
        };

            Thread t1 = new Thread(worker);
            Thread t2 = new Thread(worker);
            t1.start();
            t2.start();
    }

    public void showInfThreadWhenDirectly(){
        CyclicBarrier cyclicBarrier = new CyclicBarrier(2, () ->
                System.out.println("[Directly] Thread in invert call function is"
                        + Thread.currentThread().getId()));
        process(cyclicBarrier);
        System.out.println("[Directly] main Thread is "+ Thread.currentThread().getId());
    }

}    

输出结果如下：

[Directly] main Thread is 1
[Directly] Thread in invert call function is10
first arrival Thread in this iteration is: 10
[Directly] Thread in invert call function is10
first arrival Thread in this iteration is: 10
[Directly] Thread in invert call function is10
first arrival Thread in this iteration is: 10
[Directly] Thread in invert call function is10
first arrival Thread in this iteration is: 10
[Directly] Thread in invert call function is11
first arrival Thread in this iteration is: 11
[Directly] Thread in invert call function is10
first arrival Thread in this iteration is: 10
[Directly] Thread in invert call function is10
first arrival Thread in this iteration is: 10
[Directly] Thread in invert call function is10
first arrival Thread in this iteration is: 10
[Directly] Thread in invert call function is11
first arrival Thread in this iteration is: 11

另外，官方还有一段：“

If the barrier action does not rely on the parties being suspended when it is executed, then any of the threads in the party could execute that action when it is released. To facilitate this, each invocation of await() returns the arrival index of that thread at the barrier. You can then choose which thread should execute the barrier action, for example:

  if (barrier.await() == 0) {
     // log the completion of this iteration
   }

”

意思是说，如果回调动作“arrier action”不需要在所有工作线程都停止的状态下执行的话，那么可以随便找一个工作线程去做这个动作。为了支持这个，CyclicBarrier 的await( )方法有一个返回值，返回的就是当前线程是第几个到达约定点（barrier）的。

参考https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html