【Java并发编程四】关卡

一、什么是关卡？

　　关卡类似于闭锁，它们都能阻塞一组线程，直到某些事件发生。

　　关卡和闭锁关键的不同在于，所有线程必须同时到达关卡点，才能继续处理。闭锁等待的是事件，关卡等待的是其他线程。

二、CyclicBarrier

　　CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。

　　当线程到达关卡点时，调用await方法，await会被阻塞，直到所有的线程都到达关卡点。如果所有的线程都到达了关卡点，关卡就会被突破，这样所有的线程都被释放，关卡会重置以备下一次使用。如果对await的方法调用超时，或者阻塞中的线程被中断，那么关卡就被认为是失败的，所有对await未完成的调用都通过BrokenBarrierException终止。

　　CyclicBarrier默认的构造方法是CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。

　　实例代码如下：

public class CyclicBarrierTest
{
    public static void main(String[] args) throws InterruptedException, BrokenBarrierException
    {
        CyclicBarrier cyclicBarrier=new CyclicBarrier(4);
        for(int i=0;i<3;i++)
        {
            new Writer(cyclicBarrier).start();
        }
        cyclicBarrier.await();
        System.out.println("所有数据均写完！");
    }
    static class Writer extends Thread
    {
        CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier)
        {
            this.cyclicBarrier=cyclicBarrier;
        }
        @Override
        public void run()
        {
            try
            {
                Thread.sleep(1000);
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
            } catch (Exception e)
            {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
            
        }
    }
}

　　输出

　　

　　CyclicBarrier还提供一个更高级的构造函数CyclicBarrier(int parties, Runnable barrierAction)，用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景。代码如下：

public class CyclicBarrierTest2
{
     final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
     public static void main(String[] args)
    {
         CyclicBarrier end = new CyclicBarrier(2,new MainTask());// 两个工人的协作

         Worker worker1 = new Worker("zhang san", 5000, end);
         Worker worker2 = new Worker("li si", 8000,end);
         
         worker1.start();
         worker2.start();
    }
     static class MainTask implements Runnable
     {   
            public void run() 
            {   
                    System.out.println("执行最后的任务");   
            }   
    }  
     static class Worker extends Thread
        {
            String workerName;
            int workTime;
           
            CyclicBarrier end;
            public Worker(String workerName, int workTime, CyclicBarrier end)
            {
                this.workerName = workerName;
                this.workTime = workTime;
                this.end = end;
            }
            public void run()
            {
                try
                {
                    System.out.println("Worker " + workerName + " do work begin at "+ sdf.format(new Date()));
                    Thread.sleep(workTime);
                    System.out.println("Worker " + workerName + " do work complete at " + sdf.format(new Date()));
                } 
                catch (InterruptedException e)
                {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                }
                finally
                {
                    try
                    {
                        end.await();
                    } catch (InterruptedException | BrokenBarrierException e)
                    {
                        // TODO 自动生成的 catch 块
                        e.printStackTrace();
                    }
                }
            }
        }
}

　　输出：

　　

三、CyclicBarrier和CountDownLatch的区别

1. CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重置，因此CyclicBarrier能够处理更为复杂的业务场景，比如如果计算发送错误，可以重置计数器，并让线程重新执行一次。
2. CountDownLatch是减计数方式，计数==0时释放所有等待的线程；CyclicBarrier是加计数方式，计数达到构造方法中参数指定的值时释放所有等待的线程。
   CountDownLatch当计数到0时，计数无法被重置；CyclicBarrier计数达到指定值时，计数置为0重新开始。
   CountDownLatch每次调用countDown()方法计数减一，调用await()方法只进行阻塞，对计数没任何影响；CyclicBarrier只有一个await()方法，调用await()方法计数加1，若加1后的值不等于构造方法的值，则线程阻塞。
3. CountDownLatch： 一个或者是一部分线程 ，等待另外一部线程都完成了，再继续执行 。
   CyclicBarrier： 所有线程互相等待完成。

四、参考资料

　　1、http://ifeve.com/concurrency-cyclicbarrier/

　　2、Java并发编程实践