Java线程计数器CyclicBarrier和CountDownLatch的使用

CyclicBarrier用于Java中对于线程的计数，CyclicBarrier在创建的时候，设置一个数目，用于计数，不满足此计数时，进入的线程处于等待状态，一旦满足此计数条件，则唤醒所有等待中的线程，继续向下执行。

CountDownLatch类似于CyclicBarrier 也是起到线程的计数器作用。

不同的是CyclicBarrier 是自己或本组线程控制计数器，等待计数器满足条件时向下执行；而CountDownLatch除了自己或本组线程可以控制计数器外，其他的线程也可以控制本计数器。（举个栗子：CyclicBarrier 就像是郊游 规定10点出发 如果有人迟到 那么也是会等候的  条件是需要等待所有的参与人员都到齐后   车子才会启动；而CountDownLatch则相当于 火车10点发车 不管你来了多少人 只要到点（条件符合 计数器为0） 我就会发车）

以下为CyclicBarrier 示例代码：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CyclicBarrierTest
{
    public static void main(String[] args)
    {
        ExecutorService threadPool = Executors.newCachedThreadPool();
        //创建一个计数器为3的CyclicBarrier对象
        final CyclicBarrier cb = new CyclicBarrier(3);
        
        System.out.println("========开始测试========");
        //将三个任务添加到线程池中
        for(int i = 0; i < 3; i++)
        {
            Runnable temp = new Runnable()
            {
                @Override
                public void run()
                {
                    try
                    {
                        //cb.getNumberWaiting() 当前等待的线程数
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("即将到达集合地点1，线程：" + Thread.currentThread().getName()
                                + "已经进入。当前有" + (cb.getNumberWaiting() + 1)
                                + "个线程处于等候状态。" + ((cb.getNumberWaiting() == 2) ? "到齐啦 我们继续向前执行..." : ""));
                        
                        //在未达到计数前 处于等待状态 一旦达到计数 则唤醒所有等待中的线程 继续向下执行
                        cb.await();
                        
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("即将到达集合地点2，线程：" + Thread.currentThread().getName()
                                + "已经进入。当前有" + (cb.getNumberWaiting() + 1)
                                + "个线程处于等候状态。" + ((cb.getNumberWaiting() == 2) ? "到齐啦 我们继续向前执行..." : ""));
                        cb.await();
                        
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("即将到达集合地点3，线程：" + Thread.currentThread().getName()
                                + "已经进入。当前有" + (cb.getNumberWaiting() + 1)
                                + "个线程处于等候状态。" + ((cb.getNumberWaiting() == 2) ? "到齐啦 我们继续向前执行..." : ""));
                        cb.await();
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                    catch (BrokenBarrierException e)
                    {
                        e.printStackTrace();
                    }
                }
            };
            
            threadPool.execute(temp);
        }
        
        threadPool.shutdown();
        
        while(true)
        {
            if(threadPool.isTerminated())
            {
                System.out.println("========测试完成========");
                break;
            }
        }
    }
}

以下为CountDownLatch示例代码：

public class CountDownLatchTest
{
    public static void main(String[] args)
    {
        ExecutorService threadPool = Executors.newCachedThreadPool();
        //设置参数为1的计数器
        final CountDownLatch oneToMore = new CountDownLatch(1);
        //设置参数为3的计数器
        final CountDownLatch moreToOne = new CountDownLatch(3);
        
        /*
         * 添加3个任务 到线程池
         */
        for(int i = 0; i < 3; i++)
        {
            Runnable temp = new Runnable()
            {
                @Override
                public void run()
                {
                    try
                    {
                        System.out.println("线程：" + Thread.currentThread().getName()
                                + " 已准备就绪。");
                        /*
                         * 让线程全部出于等待状态
                         * 等待主线程将此计数器减到0时 继续向下执行
                         * [此处也可以调用oneToMore.countDown() 
                         * 让本线程自己处理 达到CyclicBarrier的效果]
                         */
                        oneToMore.await();
                        //此处sleep()是为了更好地打印结果
                        Thread.sleep(1000);
                        System.out.println("线程：" + Thread.currentThread().getName()
                                + " 已收到指令 继续向下执行。");
                        //此处sleep()是为了更好地打印结果
                        Thread.sleep((long) (Math.random() * 10000));
                        
                        System.out.println("线程：" + Thread.currentThread().getName()
                                + " 已执行完成。");
                        //将参数为3的计数器减少    moreToOne计数器为0时主线程继续执行
                        moreToOne.countDown();
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            };
            
            threadPool.execute(temp);
        }
        
        try
        {
            Thread.sleep((long) (Math.random() * 10000));
            System.out.println("线程：" + Thread.currentThread().getName() 
                    + " 准备通知线程继续向下执行...");
            //将oneToMore计数器置为0  通知其他等待中的线程 继续向下执行
            oneToMore.countDown();
            
            System.out.println("等待各线程执行完成...");
            //等待moreToOne的计数器为0  一旦其他子线程将moreToOne置为0 则继续向下执行
            moreToOne.await();
            System.out.println("线程" + Thread.currentThread().getName() 
                    + " 收到结果 OK 各线程已经执行完成");
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        
        threadPool.shutdown();
    }
}