锁 - 线程屏障CyclicBarrier

CyclicBarrier 直译是：循环屏障、可重用屏障。日常交流过程中，也可能称作：线程屏障。

跟信号量、倒数锁一样，都可以简单地实现“多个子线程执行完毕，主线程开始执行”的功能。

而屏障锁是其中较为特殊的：

• 几个线程互相等待，直到某个公共屏障点 (common barrier point)，它们最终会同时完成任务。
• 名字中的Cyclic直译为循环，他有着可循环使用的特点（可重用）。
• 对于失败的同步，CyclicBarrier 使用了一种要么全部要么全不 (all-or-none) 的破坏模式，在某个线程异常之后，全部线程将同时失败。

demo

主线程需要5个并发的初始化操作，5个线程全部执行完毕，主线程开始执行。

/**
 * @author ChenSS on 2018年2月3日
 */
public class Test {
    // 注意这里参与线程数量要改成6，主线程和子线程一起等待
    private static CyclicBarrier latch = new CyclicBarrier(6);
    
    public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
        int count = 5;
        while (count-- > 0) {
            final int n = count;
            new Thread(() -> {
                try {
                    Thread.sleep(3000 + RandomUtils.nextLong(3000));
                    System.out.println("完成第" + n + "个步骤");
                    latch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
        // 希望CyclicBarrier处理倒计时锁的功能，主线程需要和子线程一起进入等待，共同到达初始化完成的屏障点
        latch.await();
        // 引用置空
        latch = null;
        System.out.println("五个初始化操作成功，进行别的操作！");
        
    }
}

官方Demo

收录于 jdk 官方文档中的一段代码

在这个例子中，每个 worker 线程处理矩阵的一行，在处理完所有的行之前，该线程将一直在屏障处等待。

所有的子线程执行结束之后，执行所提供的 Runnable 屏障操作，总共重复执行了5次之后退出程序。

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

class Solver {
    final int N;
    final float[][] data;
    final CyclicBarrier barrier;
    
    // 设置一个退出标志位
    boolean done = true;
    // 循环5此之后，将done设置为false，退出循环
    int time = 5;
    
    // 每个Runnable负责处理一行的数据
    class Worker implements Runnable {
        int myRow;

        Worker(int row) {
            myRow = row;
        }

        public void run() {
            while(done){
                try {
                    for (float fs : data[myRow]) {
                        System.out.println(Thread.currentThread().getName() + " :" + fs);
                    }
                    barrier.await();
                } catch (InterruptedException ex) {
                    return;
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public Solver(float[][] matrix) {
        data = matrix;
        N = matrix.length;
        
        barrier = new CyclicBarrier(N, () -> {
            // 每一轮循环结束之后的回调函数
            if(time -- != 0){
                System.out.println("OK");
            } else {
                done = false;
            }
        });
        for (int i = 0; i < N; ++i) {
            new Thread(new Worker(i)).start();
        }
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        float[][] data = { { 1f, 2f }, { 3f, 4f } };
        new Solver(data);
    }
}