java 线程之concurrent中的常用工具 CyclicBarrier

一、CyclicBarrier 

　　CyclicBarrier是一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。
　　CyclicBarrier类似于CountDownLatch也是个计数器， 不同的是CyclicBarrier数的是调用了CyclicBarrier.await()进入等待的线程数， 当线程数达到了CyclicBarrier初始时规定的数目时，所有进入等待状态的线程被唤醒并继续。 CyclicBarrier就象它名字的意思一样，可看成是个障碍， 所有的线程必须到齐后才能一起通过这个障碍。 CyclicBarrier初始时还可带一个Runnable的参数，此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。

A、构造函数       创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，但它不会在每个 barrier 上执行预定义的操作。

  public CyclicBarrier(int parties) { this(parties, null);}

demo：

package com.jalja.org.thread;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class LockTest {
    public static void main(String [] args){
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
        ExecutorService executorService= Executors.newFixedThreadPool(3);
        Runnable threadTest=null;
        for(int i=0;i<3;i++){
            threadTest=new ThreadTest(cyclicBarrier);
            executorService.execute(threadTest);
        }
        executorService.shutdown();
    }
}
class ThreadTest implements Runnable{
    private CyclicBarrier cyclicBarrier;
    public ThreadTest(CyclicBarrier cyclicBarrier){
        this.cyclicBarrier=cyclicBarrier;
    }
    public void run() {
        try {
            Thread.sleep((long)(Math.random()*10000));
            System.out.println(Thread.currentThread().getName()+"开始执行");
            cyclicBarrier.await();
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }
}

B、构造函数      创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，并在启动 barrier时执行给定的屏障操作，该操作由最后一个进入 barrier 的线程执行

public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }

demo： 如果在构造CyclicBarrier对象的时候传了一个Runnable对象进去，则每次到达公共屏障点的时候都最先执行这个传进去的Runnable，然后再执行处于等待的Runnable。如果把上面的例子改成下面这样：

package com.jalja.org.thread;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class LockTest {
    public static void main(String [] args){
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3, new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName()+"======");
                try {
                    Thread.sleep((long)(Math.random()*10000));
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"======>");
            }
        });
        ExecutorService executorService= Executors.newFixedThreadPool(3);
        Runnable threadTest=null;
        for(int i=0;i<3;i++){
            threadTest=new ThreadTest(cyclicBarrier);
            executorService.execute(threadTest);
        }
        executorService.shutdown();
    }
}
class ThreadTest implements Runnable{
    private CyclicBarrier cyclicBarrier;
    public ThreadTest(CyclicBarrier cyclicBarrier){
        this.cyclicBarrier=cyclicBarrier;
    }
    public void run() {
        try {
            Thread.sleep((long)(Math.random()*10000));
            System.out.println(Thread.currentThread().getName()+"开始执行");
            cyclicBarrier.await();
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行结束");
    }
}

结果：

pool-1-thread-2开始执行
pool-1-thread-3开始执行
pool-1-thread-1开始执行
pool-1-thread-1======
pool-1-thread-1======>
pool-1-thread-1执行结束
pool-1-thread-2执行结束
pool-1-thread-3执行结束