简单了解并发工具类CyclicBarrier的使用

1.介绍
1.1.通过类名字名意思为循环屏障,因为它可以在等待的线程被释放之后重新使用.
1.2.CyclicBarrier允许一组线程全部等待彼此达到共同屏障点,然后再执行线程中await()方法后的代码.
1.3.CyclicBarrier提供了2个构造方法.

//创建一个新的 CyclicBarrier,parties为设置的等待数,当线程的等待数即调用await()方法的次数==parties,它将跳闸，即线程再往下执行.
CyclicBarrier(int parties)

//创建一个新的 CyclicBarrier ,parties为设置的等待数,barrierAction为预执行的线程,当线程的等待数即调用await()方法的次数==parties,它将跳闸,即先执行barrierAction线程,再执行线程的后续操作.
CyclicBarrier(int parties, Runnable barrierAction)

1.4重要的方法.

//等待所有 parties已经在这个障碍上调用了 await方法,即线程调用await方法,线程即处于等待状态 ，而parties加1,直到等于构造方法中声明的parties数,然后跳闸.线程再继续执行后续代码.
await() 

---

2.代码示例：
2.1示例如果调用await()的次数不等于parties

public class CyclicBarrierTest {

	//声明了2个屏障.
    static CyclicBarrier c = new CyclicBarrier(2);

    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                //此处只调用一次await.
                    c.await();
                } catch (Exception e) {
                }
                System.out.println(1);
            }
        }, "thread1");

        thread.start();
       System.out.println(2);
    }
}

thread1线程中的 1没有打印.


通过查看进程的线程状态得知,如果声明的屏障和线程调用的await方法次数不相等,调用了await的线程后的代码即不会被执行,线程一直处于waiting状态.

---

2.2.示例CyclicBarrier的重复使用.

public class BankWaterService implements Runnable {

    //创建4个屏障,处理完之后执行当前类的run方法
    private CyclicBarrier c = new CyclicBarrier(4, this);

    //假设只有4个sheet,只启动4个线程
    private Executor executor = Executors.newFixedThreadPool(4);

    //保存每个sheet计算出的银流结果
    private ConcurrentHashMap<String, Integer> sheetBankWaterCount = new ConcurrentHashMap<String, Integer>();

    //等当前类的run方法执行完毕,再让其重新执行.
    private static CountDownLatch countDownLatch = new CountDownLatch(1);

    public void count() {
        for (int i = 0; i < 4; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    //假设计算当前sheet的银流数据,
                    sheetBankWaterCount.put(Thread.currentThread().getName(), 1);

                    try {
                        //银流计算完成,插入一个屏障.
                        c.await();
                        
                 //  统计完成后,再打印线程名.    
				System.out.println(Thread.currentThread().getName());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    @Override
    public void run() {
        int result = 0;
        //汇总每个sheet计算出的结果
        for (Map.Entry<String, Integer> sheet : 	     sheetBankWaterCount.entrySet()) {
            result += sheet.getValue();
        }
        //输出结果
        System.out.println(result);

        countDownLatch.countDown();
    }

	//测试
	   public static void main(String[] args) throws InterruptedException {
        BankWaterService bankWaterService = new BankWaterService();
        bankWaterService.count();

        countDownLatch.await();
        bankWaterService.count();

    }

结果：

由结果得知：
1.当声明的屏障和线程调用的await次数相等时,先执行我们预声明的线程,
然后再执行调用await方法线程的后续代码.
2.重新调用count方法时,结果和第一次执行一样,说明CyclicBarrier的await方法是可以重复使用的.
3.CyclicBarrier就像团队中的领导,parties声明的屏障就是领导管理的员工数,线程就是员工,线程调用await方法就像是员工开会时报道,等全部员工报完道,
CyclicBarrier开始开会,会议开完后,然后员工再继续接着回去工作.