java 中的CyclicBarrier

CyclicBarrier是由ReentrantLock可重入锁和Condition共同实现的。

• 可循环（Cyclic）使用的屏障（Barrier）
• 实现原理：
  • 在CyclicBarrier的内部定义了一个Lock对象，
  • 每当一个线程调用CyclicBarrier的await方法时，将剩余拦截的线程数减1，
  • 而后判断剩余拦截数是否为0，
    • 若是不是，进入Lock对象的条件队列等待。
    • 若是是，执行barrierAction对象的Runnable方法，
  • 而后将锁的条件队列中的全部线程放入锁等待队列中，这些线程会依次的获取锁、释放锁，接着先从await方法返回，
  • 再从CyclicBarrier的await方法中返回。

================================================================

一、回环栅栏，经过它能够实现让一组线程等待至某个状态以后再所有同时执行

• 第一个版本比较经常使用，用来挂起当前线程，直至全部线程都到达barrier状态再同时执行后续任务
• 第二个版本是让这些线程等待至必定的时间，若是还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务

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

二、举个栗子：

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()+"写入数据完毕，等待其余线程写入完毕");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("全部线程写入完毕，继续处理其余任务...");
        }
    }
}

• 执行结果

三、当四个线程都到达barrier状态后，会从四个线程中选择一个线程去执行Runnable

public class Test {
    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N,new Runnable() {
            @Override
            public void run() {
                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()+"写入数据完毕，等待其余线程写入完毕");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("全部线程写入完毕，继续处理其余任务...");
        }
    }
}

四、故意让最后一个线程启动延迟

• 在前面三个线程都达到barrier以后，等待了指定的时间发现第四个线程尚未达到barrier，就抛出异常并继续执行后面的任务

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()+"全部线程写入完毕，继续处理其余任务...");
        }
    }
}

五、CyclicBarrier是能够重用的

• 初次的4个线程越过barrier状态后，又能够用来进行新一轮的使用
• CountDownLatch没法进行重复使用

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()+"全部线程写入完毕，继续处理其余任务...");
        }
    }
}