Java中CyclicBarrier 循环屏障

目录

• 一、简介
• 二、CyclicBarrier的使用
• CyclicBarrier 应用场景
• 模拟合并计算场景
• 模拟“人满发车”的场景
• 三、CyclicBarrier 源码分析
• CyclicBarrier 流程
• 几个常见的问题？
• CyclicBarrier 与 CountDownLatch的区别

一、简介

CyclicBarrier 字面意思回环栅栏（循环屏障），它可以实现让一组线程等待至某个状态（屏障点）之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。 

CyclicBarrier 作用是让一组线程相互等待，当达到一个共同点时，所有之前等待的线程再继续执行，且 CyclicBarrier 功能可重复使用。

二、CyclicBarrier的使用

构造方法：

 // parties表示屏障拦截的线程数量，每个线程调用 await 方法告诉 CyclicBarrier 我已经到达了屏障，然后当前线程被阻塞。
 public CyclicBarrier(int parties)
 // 用于在线程到达屏障时，优先执行 barrierAction，方便处理更复杂的业务场景(该线程的执行时机是在到达屏障之后再执行)

重要方法：

//屏障 指定数量的线程全部调用await()方法时，这些线程不再阻塞
// BrokenBarrierException 表示栅栏已经被破坏，破坏的原因可能是其中一个线程 await() 时被中断或者超时
public int await() throws InterruptedException, BrokenBarrierException
public int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException
//循环  通过reset()方法可以进行重置

CyclicBarrier 应用场景

• 利用 CyclicBarrier 可以用于多线程计算数据，最后合并计算结果的场景。
• 利用 CyclicBarrier的计数器能够重置，屏障可以重复使用的特性，可以支持类似“人满发车”的场景

模拟合并计算场景

利用 CyclicBarrier 可以用于多线程计算数据，最后合并计算结果的场景。

public class CyclicBarrierTest2 {
    //保存每个学生的平均成绩
    private Conc urrentHashMap map=new ConcurrentHashMap();
    private ExecutorService threadPool= Executors.newFixedThreadPool(3);
    private CyclicBarrier cb=new CyclicBarrier(3,()->{
        int result=0;
        Set set = map.keySet();
        for(String s:set){
            result+=map.get(s);
        }
        System.out.println("三人平均成绩为:"+(result/3)+"分");
    });
    public void count(){
        for(int i=0;i<3;i++){
            threadPool.execute(new Runnable(){

                @Override
                public void run() {
                    //获取学生平均成绩
                    int score=(int)(Math.random()*40+60);
                    map.put(Thread.currentThread().getName(), score);
                    System.out.println(Thread.currentThread().getName()
                            +"同学的平均成绩为："+score);
                    try {
                        //执行完运行await(),等待所有学生平均成绩都计算完毕
                        cb.await();
                    } catch (InterruptedException | BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }

            });
        }
    }
    public static void main(String[] args) {
        CyclicBarrierTest2 cb=new CyclicBarrierTest2();
        cb.count();
    }
}

模拟“人满发车”的场景

利用CyclicBarrier的计数器能够重置，屏障可以重复使用的特性，可以支持类似“人满发车”的场景

public class CyclicBarrierTest3 {
    public static void main(String[] args) {
        AtomicInteger counter = new AtomicInteger();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                5, 5, 1000, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(100),
                (r) -> new Thread(r, counter.addAndGet(1) + " 号 "),
                new ThreadPoolExecutor.AbortPolicy());

        CyclicBarrier cyclicBarrier = new CyclicBarrier(5,
                () -> System.out.println("裁判：比赛开始~~"));

        for (int i = 0; i < 10; i++) {
            threadPoolExecutor.submit(new Runner(cyclicBarrier));
        }

    }
    static class Runner extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Runner (CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }
        @Override
        public void run() {
            try {
                int sleepMills = ThreadLocalRandom.current().nextInt(1000);
                Thread.sleep(sleepMills);
                System.out.println(Thread.currentThread().getName() + " 选手已就位, 准备共用时： " + sleepMills + "ms" + cyclicBarrier.getNumberWaiting());
                cyclicBarrier.await();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
        }
    }

}

输出结果：

3 号  选手已就位, 准备共用时： 78ms0
1 号  选手已就位, 准备共用时： 395ms1
5 号  选手已就位, 准备共用时： 733ms2
2 号  选手已就位, 准备共用时： 776ms3
4 号  选手已就位, 准备共用时： 807ms4
裁判：比赛开始~~
4 号  选手已就位, 准备共用时： 131ms0
3 号  选手已就位, 准备共用时： 256ms1
2 号  选手已就位, 准备共用时： 291ms2
1 号  选手已就位, 准备共用时： 588ms3
5 号  选手已就位, 准备共用时： 763ms4
裁判：比赛开始~~

三、CyclicBarrier 源码分析

CyclicBarrier 流程

主要是的流程：

• 获取锁 如果 count != 0 就进入阻塞；
• 进入阻塞之前，首先需要进入条件队列，然后释放锁，最后阻塞；
• 如果 count != 0 会进行一个唤醒，将所有的条件队列中的节点转换为阻塞队列；
• 被唤醒过后会进行锁的获取，如果锁获取失败，会进入 lock 的阻塞队列；
• 如果锁获取成功，进行锁的释放，以及唤醒，同步队列中的线程。

下面是一个简单的流程图：

下面是具体的一些代码调用的流程：

几个常见的问题？

• 1.一组线程在触发屏障之前互相等待，最后一个线程到达屏障后唤醒逻辑是如何实现的. 唤醒的过程是通过调用 java.util.concurrent.locks.Condition#signalAll唤醒条件队列上的所有节点。
• 2.删栏循环使用是如何实现的? 实际上一个互斥锁 ReentrantLock 的条件队列和阻塞队列的转换。
• 3.条件队列到同步队列的转换实现逻辑 ? 转换过程中，首先会先将条件队列中所有的阻塞线程唤醒，然后会去获取 lock 如果获取失败，就进入同步队列。

CyclicBarrier 与 CountDownLatch的区别

• CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景，比如如果计算发生错误，可以重置计数器，并让线程们重新执行一次
• CyclicBarrier还提供getNumberWaiting(可以获得CyclicBarrier阻塞的线程数量)、isBroken(用来知道阻塞的线程是否被中断)等方法。
• CountDownLatch会阻塞主线程，CyclicBarrier不会阻塞主线程，只会阻塞子线程。
• CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同。CountDownLatch一般用于一个或多个线程，等待其他线程执行完任务后，再执行。CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行。
• CyclicBarrier 还可以提供一个 barrierAction，合并多线程计算结果。
• CyclicBarrier是通过ReentrantLock的"独占锁"和Conditon来实现一组线程的阻塞唤醒的，而CountDownLatch则是通过AQS的“共享锁”实现

到此这篇关于Java中CyclicBarrier 循环屏障的文章就介绍到这了,更多相关Java CyclicBarrier 内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！