java.util.concurrent.CyclicBarrier

CyclicBarrier

可循环屏障，作用是使得一组线程相互等待，直到最后一个线程到达屏障后，释放所有阻塞在该屏障上的线程，用于线程同步通信。

public class CyclicBarrier {
    private static class Generation {
        Generation() {} // 保护构造器              
        boolean broken; // 确认屏障是否被打破                
    }
    // 锁对象
    private final ReentrantLock lock = new ReentrantLock();
    // 锁对象上的一个阻塞队列
    private final Condition trip = lock.newCondition();
    // 线程数量，跟随CyclicBarrier初始化
    private final int parties;
    // 设置最后一个线程到达后，需要执行的后续线程
    private final Runnable barrierCommand;
    // 初始化屏障
    private Generation generation = new Generation();
    // 内部计数器，跟随CyclicBarrier初始化，与parties初始值相同
    private int count;
    // 屏障换代，即屏障更新
    private void nextGeneration() {
        // 屏障更新前唤醒所有阻塞在屏障上的线程
        trip.signalAll();
        // 重置内部计数器
        count = parties;
        // 屏障更新
        generation = new Generation();
    }
    // 打破屏障
    private void breakBarrier() {
        // 更改屏障状态，表示屏障被打破
        generation.broken = true;
        // 重置内部计数器
        count = parties;
        // 屏障打破后唤醒所有阻塞在屏障上的线程
        trip.signalAll();
    }
    // 核心-->等待方法
    private int dowait(boolean timed, long nanos) throws InterruptedException, BrokenBarrierException,
               TimeoutException {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            final Generation g = generation; // 获取当代屏障

            if (g.broken) // 最后一个线程到达前屏障被打破，则抛出异常
                throw new BrokenBarrierException();

            if (Thread.interrupted()) { // 线程中断，中断后立即打破屏障并唤醒所有阻塞在当代屏障上的线程，最后抛出异常
                breakBarrier();
                throw new InterruptedException();
            }

            int index = --count; // 线程到达后，内部计数器-1
            if (index == 0) {  // 当最后一个线程到达后，执行指定后续线程barrierCommand
                boolean ranAction = false; // 设置标志位
                try {
                    final Runnable command = barrierCommand; // 后续线程
                    if (command != null) // 指定线程不为空
                        command.run(); // 执行线程
                    ranAction = true; // 线程执行完改变标志位
                    nextGeneration(); // 最后一个线程到达，打破屏障并更新屏障
                    return 0; // 返回内部计数器的值
                } finally {
                    if (!ranAction) // 无论后续线程执行结果如何，确保屏障必须被打破
                        breakBarrier();
                }
            }

            // 循环直至屏障打破，线程中断，超时
            for (;;) {
                try {
                    if (!timed) 
                        trip.await(); // 不指定时间时，线程等待，Condition.await()
                    else if (nanos > 0L)
                        // 指定时间时，线程等待，Condition.awaitNanos(long nanosTimeout) 
                        nanos = trip.awaitNanos(nanos);
                } catch (InterruptedException ie) {
                    if (g == generation && ! g.broken) { // 若当前线程在等待期间被中断则打破屏障唤醒其他线程
                        breakBarrier();
                        throw ie;
                    } else {
                        Thread.currentThread().interrupt(); // 若在捕获中断异常前已经完成等待, 则直接调用中断操作
                    }
                }
                // 当最后一个线程到达前屏障被打破，抛出异常
                if (g.broken)
                    throw new BrokenBarrierException();
                // 最后一个线程到达，屏障正常更替，返回线程阻塞时内部计数器的值
                if (g != generation)
                    return index;
                // 超时发生时打破屏障，抛出异常
                if (timed && nanos <= 0L) {
                    breakBarrier();
                    throw new TimeoutException();
                }
            }
        } finally {
            lock.unlock();
        }
    }
    // 初始化CyclicBarrier，指定计数器大小，指定后续执行线程
    public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }
    // 无指定后续线程过的初始化
    public CyclicBarrier(int parties) {
        this(parties, null);
    }
    // 线程等待
    public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe);
        }
    }
    // 线程等待指定时间
    public int await(long timeout, TimeUnit unit)
        throws InterruptedException,
               BrokenBarrierException,
               TimeoutException {
        return dowait(true, unit.toNanos(timeout));
    }
    // 重置内部计数器
    public void reset() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            breakBarrier();   // 打破当代屏障
            nextGeneration(); // 设置新的屏障
        } finally {
            lock.unlock();
        }
    }
}

解析在源代码的注释中。接下来是流程图，

方法	说明
public CyclicBarrier(int parties, Runnable barrierAction)	初始化CyclicBarrier，指定计数器大小，指定后续执行线程
public CyclicBarrier(int parties)	无指定后续线程过的初始化
int wait()	线程在屏障处等待
int await(long timeout, TimeUnit unit)	线程在屏障处等待指定时间
int getNumberWaiting()	返回目前正在等待屏障的线程数量
int getParties()	返回屏障被打破所需的线程数量
boolean isBroken()	检查屏障是否被打破
void reset()	重置屏障内部计数器，即重启屏障

举例：对二维数组array[4][4]的每一行进行排序，由4个线程来进行，每个线程负责一行。当所有线程结束后执行后续线程，输出Over…

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

public class Thread11 {
    public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
        int[][] array = new int[][]{{1,5,3,6},{4,5,7,8},{1,4,2,7},{4,6,2,8}};
        Solver solver = new Solver(array);
        for (int i = 0; i < solver.N; i++) {
            Thread thread = new Thread(new Worker(i,solver));
            thread.start();
        }
//        System.out.println(Arrays.deepToString(array));
    }
}
class Solver {
    final int N;
    final int[][] data;
    final CyclicBarrier barrier;
    Runnable barrierAction = () -> {
        System.out.println("Over...");
    };
    public Solver(int[][] matrix) {
        data = matrix;
        N = matrix.length;
        barrier = new CyclicBarrier(N, barrierAction);
    }
}
class Worker implements Runnable {
    Solver solver;
    int myRow;
    public Worker(int row, Solver solver) {
        this.myRow = row;
        this.solver = solver;
    }

    @Override
    public void run() {
        Arrays.sort(solver.data[myRow]);
        System.out.println(myRow + " = " +Arrays.toString(solver.data[myRow]));
        try {
            solver.barrier.await();
        } catch (InterruptedException | BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

END