【JAVA核心知识】15.2：线程控制器CyclicBarrier

简介​

可重复使用的线程控制器、适用于多个线程需到达某个状态之后再同时开始执行的场景，就好似有道屏障，只有在屏障处等待的线程到指定数量这个屏障才会打开。

常用方法

• CyclicBarrier(int parties, Runnable barrierAction)：构造方法，parties标识要控制的线程数，即当多少个线程在屏障处等待时就放行。barrierAction为需要在放行时同步执行的操作。
• CyclicBarrier(int parties)：构造方法，parties标识要控制的线程数，即当多少个线程在屏障处等待时就放行。
• int getParties()：获得要控制的线程数，即当多少个线程在屏障处等待时就放行。
• int await():等待屏障处线程达到数量
• int await(long timeout, TimeUnit unit)：等待屏障处线程达到数量 带超时时间
• boolean isBroken()：屏障是否已经被破坏 true为已被破坏
• void reset()：CyclicBarrier可重复使用并不代表屏障每开启一次就要调这个方法一次。每当屏障处到达指定数量的等待线程，屏障会开启并自动关闭等待下一波线程。无需每开启一次就重置一次。这个方法使屏障恢复初始状态，不过如果在重置时有线程在屏障处等待，则抛出BrokenBarrierException.
• int getNumberWaiting()：获得当前在屏障处等待的线程数

示例

package sync;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CyclicBarrierTest {

    public static void main(String[] args) {
        Runnable allAwaitRun = new Runnable() {
            
            @Override
            public void run() {
                System.out.println("大家都执行完毕了，准备下一步工作喽");
            }
        };
        final CyclicBarrier c = new CyclicBarrier(3, allAwaitRun);  // 参数二为屏障放行之后要启的线程
                                                                    // 如果你实际有3个线程但是屏障设置为2，那么先到的2个会被屏障放行，
                                                                    //最后一个屏障并不知道也不去管，导致最后一个到的一直等待或者超时报TimeoutException
        Runnable r1 = new Runnable() {
            
            @Override
            public void run() {
                System.out.println("线程1开始进行第一步工作...");
                try {
                    Thread.sleep(500); // 等待模式耗时操作
                    System.out.println("线程1第一步工作完毕，进入等待状态...当前等待线程量 - " + c.getNumberWaiting());
                    try {
                        System.out.println("r1.await - " + c.await(2, TimeUnit.SECONDS));  // await返回该线程到达屏障的顺序，最快的为n-1,最慢的为0
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    } catch (TimeoutException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程1通过屏障");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        
        Runnable r2 = new Runnable() {
            
            @Override
            public void run() {
                System.out.println("线程2开始进行第一步工作...");
                try {
                    Thread.sleep(1000);// 等待模式耗时操作
                    System.out.println("c2 - " + c.isBroken());
                    System.out.println("线程2第一步工作完毕，进入等待状态...当前等待线程量 - " + c.getNumberWaiting());
                    try {
                        System.out.println("r2.await - " + c.await(2, TimeUnit.SECONDS));
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    } catch (TimeoutException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程2通过屏障");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        
        Runnable r3 = new Runnable() {
            
            @Override
            public void run() {
                System.out.println("线程3开始进行第一步工作...");
                try {
                    Thread.sleep(1500);// 等待模式耗时操作
//                    Thread.sleep(5000);// 等待模式耗时操作   5s的话显而易见的会报超时,由先到屏障处即await返回值为n-1的那个线程抛出TimeoutException
                                            //超时异常一经抛出，屏障被破坏，因此会导致其他已在屏障处的等待线程await抛出 BrokenBarrierException.
                                            // (依据对这个异常的处理(catch还是throws(Callable可抛出异常))来判定线程是继续执行还是抛出停止)
                                            //但是对线程3因为此线程延迟5s，所以此时还没到屏障处
                                            // 所以会继续执行，直至到达屏障处发现屏障已被破坏，抛出BrokenBarrierException
                    System.out.println("线程3第一步工作完毕，进入等待状态...当前等待线程量 - " + c.getNumberWaiting());
                    try {
                        System.out.println("r3.await - " + c.await(2, TimeUnit.SECONDS));
                    } catch (BrokenBarrierException e) {
                        System.out.println("e - " + c.isBroken());  //  设置sleep(5000)时屏障被击穿   这里为true
                        e.printStackTrace();
                    } catch (TimeoutException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程3通过屏障");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        
        new Thread(r1).start();
        new Thread(r2).start();
        new Thread(r3).start();

        System.out.println("c.getParties() - " + c.getParties()); // CyclicBarrier掌控的线程数
        
        c.reset(); // 重置，如果此时有线程在屏障处等待，那么抛出BrokenBarrierException
    }

}

运行结果：

线程1开始进行第一步工作...
线程3开始进行第一步工作...
c.getParties() - 3
线程2开始进行第一步工作...
线程1第一步工作完毕，进入等待状态...当前等待线程量 - 0
c2 - false
线程2第一步工作完毕，进入等待状态...当前等待线程量 - 1
线程3第一步工作完毕，进入等待状态...当前等待线程量 - 2
大家都执行完毕了，准备下一步工作喽
r3.await - 0
线程3通过屏障
r1.await - 2
线程1通过屏障
r2.await - 1
线程2通过屏障

PS：
【JAVA核心知识】系列导航 [持续更新中…]
上篇导航：15.1：线程控制器CountDownLatch
下篇导航：15.3：线程控制器Semaphore
欢迎关注…
​