CyclicBarrier 源碼學習

1、CyclicBarrier 的作用

一種同步輔助，允許一組線程彼此等待到達一個共同的障礙點。cyclicbarrier在包含固定大小的線程的程序中非常有用，這些線程有時必須彼此等待。這個屏障被稱爲循環，因爲它可以在釋放等待的線程之後重用。

2、核心結構

// 使用ReentrantLock加鎖
private final ReentrantLock lock = new ReentrantLock();
// 鎖條件變量，用來處理鎖等待，鎖喚醒
private final Condition trip = lock.newCondition();
// 初始化等待工作(屏障)的數量
private final int parties;
// 構造函數如果設置Runnable，則會觸發Runnable方法
private final Runnable barrierCommand;
// 用於控制屏障的循環使用，如果 generation.token 爲true，表示這個屏障已損壞
private Generation generation = new Generation(); 
// 正在等待的工作(屏障)的數量
private int count;

3、兩個構造函數

// parties等待工作(屏障)的數量
public CyclicBarrier(int parties) {
    this(parties, null);
}
// parties等待工作(屏障)的數量
// Runnable表示任務會在所有線程到達屏障後執行
public CyclicBarrier(int parties, Runnable barrierAction) {
	if (parties <= 0)
		throw new IllegalArgumentException();
	this.parties = parties;
	this.count = parties;
	this.barrierCommand = barrierAction;
 }

4、等待方法

// 等待直到所有方都調用了這個屏障。
public int await() throws InterruptedException, BrokenBarrierException {
    try {
        return dowait(false, 0L);
    } catch (TimeoutException toe) {
        throw new Error(toe); // cannot happen
    }
}
/**
 * 主要屏障代碼，涵蓋各種策略。
 * 每當線程執行await，內部變量count--
 * 如果count!=0，自旋在鎖條件變量trip上等待
 * 如果count==0，喚醒所有等待線程，如果初始化加載Runnable，那麼執行這個方法，並開始
 */
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;
        if (index == 0) {  // tripped
            boolean ranAction = false;
            try {
                final Runnable command = barrierCommand;
                if (command != null)
                    command.run();
                ranAction = true;
                nextGeneration();
                return 0;
            } finally {
                if (!ranAction)
                    breakBarrier();
            }
        }
        // loop until tripped, broken, interrupted, or timed out
        for (;;) {
            try {
                if (!timed)
                    trip.await();
                else if (nanos > 0L)
                    nanos = trip.awaitNanos(nanos);
            } catch (InterruptedException ie) {
                if (g == generation && ! g.broken) {
                    breakBarrier();
                    throw ie;
                } else {
                    // We're about to finish waiting even if we had not
                    // been interrupted, so this interrupt is deemed to
                    // "belong" to subsequent execution.
                    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();
    }
}

5、屏障循環使用

// 更新屏障狀態並喚醒所有人。
private void nextGeneration() {
    // 喚醒上一代的所有等待線程
    trip.signalAll();
    // 設置新的控制屏障
    count = parties;
    generation = new Generation();
}

6、實例測試

有一組工作者需要完成一組工作。工作之前需要等待所有工作者全部準備好，準備好以後所有工作者開始工作。

github

/**
 * 
 * CyclicBarrier用法實例
 * 有一組工作者需要完成一組工作。工作之前需要等待所有工作者全部準備好，準備好以後所有工作者開始工作。
 * 
 * @version 1.0
 */
public class CyclicBarrierDriverDemo {

	public static void main(String[] args) {
		Integer N = 5;
		Runnable barrierAction = new Runnable() {
			public void run() {
				System.out.println("工作者全部準備好了，可以開始工作了。");
			}
		};
		
		CyclicBarrier cyclicBarrier = new CyclicBarrier(N, barrierAction);
		for (int i = 0; i < N; i++) {
			new CyclicBarrierWorker(cyclicBarrier, i).start();
		}
	}
	
}

class CyclicBarrierWorker extends Thread {
	CyclicBarrier barrier;
	private Integer i;
	
	public CyclicBarrierWorker(CyclicBarrier barrier, Integer i) {
		this.barrier = barrier;
		this.i = i;
	}
	
	public void run() {
		try {
			Random random = new Random();
			Integer prepare = random.nextInt(1000);
			Thread.sleep(prepare);
			System.out.println("工作者" + i + "準備好了，準備時間 " + prepare + " 毫秒。");
			barrier.await();
			Integer work = random.nextInt(1000);
			Thread.sleep(work);
			System.out.println("工作者" + i + "工作完成，工作時間 " + work + " 毫秒。");
		} catch (Exception e) {

		}
	}
	
}