CyclicBarrier

最新推荐文章于 2024-06-21 22:23:19 发布

被揍的皮卡丘

最新推荐文章于 2024-06-21 22:23:19 发布

阅读量366

点赞数 6

分类专栏： java 并发编程文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_34250794/article/details/136393266

版权

java 并发编程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

CyclicBarrier

/**
 * 前面的Cyclic意为循环，也就是说这个计数器可以反复使用。
 * 比如，我们将计数器设置为10，那么凑齐第一批10个线程后，计数器就会归零，
 * 接着凑齐下一批10个线程，这就是循环栅栏内在的含义
 */

package com.android.arthogritybrary.cyclicbar;

import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {

    public static class Soldier implements Runnable {

        private String soldier;
        private final CyclicBarrier cyclicBarrier;

        public Soldier(String soldier, CyclicBarrier cyclicBarrier) {
            this.soldier = soldier;
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {

            try {
                //等待所有士兵到齐
                cyclicBarrier.await();//1
                doWork();
                //等待所有士兵完成任务
                cyclicBarrier.await();//3

                /**
                 * CyclicBarrier.await()方法可能会抛出两个异常。
                 * 一个是InterruptedException，也就是在等待过程中，线程被中断，应该说这是一个非常常见的异常。
                 * 大部分迫使线程等待的方法都可能会抛出这个异常，使得线程在等待时依然可以响应外部紧急事件。
                 * 另一个异常则是CyclicBarrier特有的BrokenBarrierException。
                 * 一旦遇到这个异常，则表示当前的CyclicBarrier已经破损了，可能系统没有办法等待所有线程到齐了
                 */
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

        public void doWork() {
            try {
                Thread.sleep(Math.abs(new Random().nextInt()%10000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(soldier + ":任务完成");
        }
    }

    public static class BarrierRun implements Runnable {
        boolean flag;
        int N;

        public BarrierRun(boolean flag, int n) {
            this.flag = flag;
            N = n;
        }

        @Override
        public void run() {
            if (flag) {
                System.out.println("士兵 "+N + "个,任务完成");//4
            } else {
                System.out.println("士兵 "+N + "个,集合完毕");//2
                flag = true;
            }

        }
    }

    public static void main(String[] args) {
        int N = 10;
        Thread[] allsoldiers = new Thread[N];
        boolean flag = false;

        //zsg N 个线程同步,new BarrierRun 是一个Runable ,当这N 个线程都来到这个栅栏的时候就会执行这个Runable
        CyclicBarrier cyclicBarrier = new CyclicBarrier(N, new BarrierRun(flag, N));
        System.out.println("集合队伍！");
        for (int i = 0; i < N; i++) {
            System.out.println("士兵" + i + "报道");
            //zsg 每一个线程里都传入了相同的cyclicBarrier
            allsoldiers[i] = new Thread(new Soldier("士兵"+i, cyclicBarrier));
            allsoldiers[i].start();
        }
    }
}