java并发中的CyclicBarrier

最新推荐文章于 2025-06-21 17:13:59 发布

小气鬼Sweet

最新推荐文章于 2025-06-21 17:13:59 发布

阅读量305

点赞数

CC 4.0 BY-SA版权

分类专栏： java并发学习文章标签： java并发

本文链接：https://blog.youkuaiyun.com/Hzt_fighting_up/article/details/78137082

java并发学习专栏收录该内容

16 篇文章

订阅专栏

本文详细介绍了Java并发包中的CyclicBarrier类及其使用方法，通过一个赛马程序实例展示了如何利用CyclicBarrier来同步多个线程，确保所有线程在达到某个检查点后继续执行。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

CyclicBarrier介绍：翻译过来就是回旋栅栏。主要适用于这样的场景，你希望创建一组任务，他们并行的执行工作，然后在进行工作下一个步骤之前等待，直至所有任务完成。
它有两个构造函数：
```
public CyclicBarrier(int parties, Runnable barrierAction) {}
public CyclicBarrier(int parties) {}
```
parties代表一次并行的任务，barrierAction当这些线程都达到barrier状态时要执行的任务，会选择一个线程去执行这个Runnable

重载了一个方法await()

public int await() throws InterruptedException, BrokenBarrierException { }
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { }

第一个方法用来挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务。第二个方法是让这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务。
一个实列
简单介绍：模拟了一个赛马的过程，每个马都有都有一个栅栏，当执行到runnable方法里，执行完相应的操作以后，就会调用await()方法将自己挂起，直到所有执行的线程都到达栅栏
在HorseRace类中，首先先添加参加马赛的马，以及初始化了CyclicBarrier对象

代码如下：
Horse类：

public class Horse implements Runnable {
    private static int counter = 0;
    private final int id = counter++;
    private int strides = 0;
    private static Random rand = new Random(47);
    private static CyclicBarrier barrier;
    public Horse(CyclicBarrier b) { barrier = b; }
    public synchronized int getStrides() { return strides; }
    public void run() {
        try {
            while(!Thread.interrupted()) {
                synchronized(this) {
                    strides += rand.nextInt(3); // Produces 0, 1 or 2
                }
                barrier.await();  //在栅栏处等待
            }
        } catch(InterruptedException e) {
            // A legitimate way to exit
        } catch(BrokenBarrierException e) {
            // This one we want to know about
            throw new RuntimeException(e);
        }
    }
    public String toString() { return "Horse " + id + " "; }
    public String tracks() {
        StringBuilder s = new StringBuilder();
        for(int i = 0; i < getStrides(); i++)
            s.append("*");
        s.append(id);
        return s.toString();
    }
}

HorseRace类：

public class HorseRace {
    static final int FINISH_LINE = 75;
    private List<Horse> horses = new ArrayList<Horse>();
    private ExecutorService exec =
            Executors.newCachedThreadPool();
    private CyclicBarrier barrier;
    public HorseRace(int nHorses, final int pause) {
        barrier = new CyclicBarrier(nHorses, new Runnable() {
            public void run() {
                System.out.println("执行runnable方法的线程: " + Thread.currentThread().getName());
                StringBuilder s = new StringBuilder();
                for(int i = 0; i < FINISH_LINE; i++)
                    s.append("="); // The fence on the racetrack
                System.out.println(s);
                for(Horse horse : horses)
                    System.out.println(horse.tracks());
                for(Horse horse : horses)
                    if(horse.getStrides() >= FINISH_LINE) {
                        System.out.println(horse + "won!");
                        exec.shutdownNow();
                        return;
                    }
                try {
                    TimeUnit.MILLISECONDS.sleep(pause);
                } catch(InterruptedException e) {
                    System.out.println("barrier-action sleep interrupted");
                }
            }
        });

        for(int i = 0; i < nHorses; i++) {
            Horse horse = new Horse(barrier);
            horses.add(horse);
            exec.execute(horse);
        }
    }

    public static void main(String[] args) {
        int nHorses = 7;
        int pause = 200;

        new HorseRace(nHorses, pause);
    }
}

为了看是否只选择了一个线程去执行Runnable，在HorseRace中打印了一下当前的线程的名字，从结果来看确实是这样的。