CyclicBarrier的简介及应用场景

不念不忘少年蓝@ 2022-01-11 06:07 397阅读 0赞

原文:[https://blog.csdn.net/yuruixin\_china/article/details/82118770][https_blog.csdn.net_yuruixin_china_article_details_82118770]

CyclicBarrier（循环屏障） 直译为可循环使用（Cyclic）的屏障（Barrier）。它可以让一组线程到达一个屏障（同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续工作

CyclicBarrier构造函数

public CyclicBarrier(int parties);//parties表示屏障拦截的线程数量  
public CyclicBarrier(int parties, Runnable barrierAction);//parties表示屏障拦截的线程数量,在线程到达屏障时，优先执行barrierAction  
应用场景： CyclicBarrier可以用于多线程计算数据，最后合并计算结果的应用场景。比如现在需要计算10个人12个月内的工资详细，可以将线程分为10个，分别计算每个人的工资，最后，再用barrierAction将这些线程的计算结果进行整合，得出最后结果。

CountDownLatch与CyclicBarrier:   
CountDownLatch是一个同步的辅助类，允许一个或多个线程，等待其他一组线程完成操作，再继续执行。   
CyclicBarrier是一个同步的辅助类，允许一组线程相互之间等待，达到一个共同点，再继续执行。   
区别:

CountDownLatch的计数器只能使用一次。而CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景，比如如果计算发生错误，可以重置计数器，并让线程们重新执行一次  
CyclicBarrier还提供getNumberWaiting(可以获得CyclicBarrier阻塞的线程数量)、isBroken(用来知道阻塞的线程是否被中断)等方法。  
CountDownLatch会阻塞主线程，CyclicBarrier不会阻塞主线程，只会阻塞子线程。  
代码实例：   
假设要分别计算员工1和员工2的工资，并在都计算完之后进行整合操作，代码实现逻辑如下

package com.concurrency.yuxin.demo;
    
    import java.util.concurrent.BrokenBarrierException;
    import java.util.concurrent.CyclicBarrier;
    
    public class CyclicBarrierDemo {
    
        public static void main(String[] args) throws InterruptedException{
    
            CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Runnable() {
                @Override
                public void run() {
                    System.out.println("汇总已分别计算出的两个员工的工资");
                }
            });
    
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("计算出员工1的工资");
                    try {
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            }, "thread1");
    
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("计算出员工2的工资");
                    try {
                        cyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            }, "thread2");
    
    
            thread1.start();
            thread2.start();
    
            System.out.println("====end====");
        }
    
    }

输出结果：

====end====
    计算出员工1的工资
    计算出员工2的工资
    汇总已分别计算出的两个员工的工资

从输出结果可以看出   
**1. 主线程未被阻塞   
2. barrierAction在各线程执行结束之后触发**

[https_blog.csdn.net_yuruixin_china_article_details_82118770]: https://blog.csdn.net/yuruixin_china/article/details/82118770