摘要：因為該在釋放等待線程后可以重用，所以稱它為循環(huán)的。若在繼續(xù)所有參與線程之前更新共享狀態(tài)，此屏障操作很有用。返回要求啟動此的參與者數(shù)目。查詢此屏障是否處于損壞狀態(tài)。將屏障重置為其初始狀態(tài)。
本人郵箱:
歡迎轉(zhuǎn)載,轉(zhuǎn)載請注明網(wǎng)址 http://blog.csdn.net/tianshi_kco
github: https://github.com/kco1989/kco
代碼已經(jīng)全部托管github有需要的同學(xué)自行下載
引言
一個同步輔助類，它允許一組線程互相等待，直到到達某個公共屏障點 (common barrier point)。在涉及一組固定大小的線程的程序中，這些線程必須不時地互相等待，此時 CyclicBarrier 很有用。因為該 barrier 在釋放等待線程后可以重用，所以稱它為循環(huán) 的 barrier。
理論
CyclicBarrier 支持一個可選的 Runnable 命令，在一組線程中的最后一個線程到達之后（但在釋放所有線程之前），該命令只在每個屏障點運行一次。若在繼續(xù)所有參與線程之前更新共享狀態(tài)，此屏障操作 很有用。
示例用法：下面是一個在并行分解設(shè)計中使用 barrier 的例子：
class Solver {
final int N;
final float[][] data;
final CyclicBarrier barrier;
class Worker implements Runnable {
int myRow;
Worker(int row) {
myRow = row;
}
public void run() {
while (!done()) {
processRow(myRow);
try {
barrier.await();
} catch (InterruptedException ex) {
return;
} catch (BrokenBarrierException ex) {
return;
}
}
}
}
public Solver(float[][] matrix) {
data = matrix;
N = matrix.length;
barrier = new CyclicBarrier(N,
new Runnable() {
public void run() {
mergeRows(...);
}
});
for (int i = 0; i < N; ++i)
new Thread(new Worker(i)).start();
waitUntilDone();
}
}
在這個例子中，每個 worker 線程處理矩陣的一行，在處理完所有的行之前，該線程將一直在屏障處等待。處理完所有的行之后，將執(zhí)行所提供的 Runnable 屏障操作，并合并這些行。如果合并者確定已經(jīng)找到了一個解決方案，那么 done() 將返回 true，所有的 worker 線程都將終止。
如果屏障操作在執(zhí)行時不依賴于正掛起的線程，則線程組中的任何線程在獲得釋放時都能執(zhí)行該操作。為方便此操作，每次調(diào)用 await() 都將返回能到達屏障處的線程的索引。然后，您可以選擇哪個線程應(yīng)該執(zhí)行屏障操作，例如：
if (barrier.await() == 0) {
// log the completion of this iteration
}
對于失敗的同步嘗試，CyclicBarrier 使用了一種要么全部要么全不 (all-or-none) 的破壞模式：如果因為中斷、失敗或者超時等原因，導(dǎo)致線程過早地離開了屏障點，那么在該屏障點等待的其他所有線程也將通過 BrokenBarrierException（如果它們幾乎同時被中斷，則用 InterruptedException）以反常的方式離開。
內(nèi)存一致性效果：線程中調(diào)用 await() 之前的操作 happen-before 那些是屏障操作的一部份的操作，后者依次 happen-before 緊跟在從另一個線程中對應(yīng) await() 成功返回的操作。
CyclicBarrier(int parties) 創(chuàng)建一個新的 CyclicBarrier，它將在給定數(shù)量的參與者（線程）處于等待狀態(tài)時啟動，但它不會在啟動 barrier 時執(zhí)行預(yù)定義的操作。
CyclicBarrier(int parties, Runnable barrierAction) 創(chuàng)建一個新的 CyclicBarrier，它將在給定數(shù)量的參與者（線程）處于等待狀態(tài)時啟動，并在啟動 barrier 時執(zhí)行給定的屏障操作，該操作由最后一個進入 barrier 的線程執(zhí)行。
await() 在所有參與者都已經(jīng)在此 barrier 上調(diào)用 await 方法之前，將一直等待。
await(long timeout, TimeUnit unit) 在所有參與者都已經(jīng)在此屏障上調(diào)用 await 方法之前將一直等待,或者超出了指定的等待時間。
getNumberWaiting() 返回當前在屏障處等待的參與者數(shù)目。
getParties() 返回要求啟動此 barrier 的參與者數(shù)目。
isBroken() 查詢此屏障是否處于損壞狀態(tài)。
reset() 將屏障重置為其初始狀態(tài)。
例子
還是一樣,理論是比較枯燥的,咱們還是舉例來說,比較生動一點.一些教科書舉一些1~100000分批累加例子.咱們不舉這種比較無聊的例子.旅游,相信很多人都喜歡吧!旅游的套路一般都出發(fā)點集合,入住酒店,到旅游點1,再到旅游點2,再到旅游點3,在集合返回.每次都某一個地點時.導(dǎo)游都會清點人數(shù).不要把人給弄丟.ok,開始編碼...
首先寫一個旅游類 TourismRunnable,run方法很簡單就調(diào)用tourism()旅游的行程,然后在tourism,再調(diào)用旅游點路程,看代碼..
public class TourismRunnable implements Runnable{
CyclicBarrier cyclicBarrier;
Random random;
public TourismRunnable(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
this.random = new Random();
}
@Override
public void run() {
tourism();
}
/**
* 旅游過程
*/
private void tourism() {
goToStartingPoint();
goToHotel();
goToTourismPoint1();
goToTourismPoint2();
goToTourismPoint3();
goToEndPoint();
}
/**
* 裝備返程
*/
private void goToEndPoint() {
goToPoint("飛機場,準備登機回家");
}
/**
* 到達旅游點3
*/
private void goToTourismPoint3() {
goToPoint("旅游點3");
}
/**
* 到達旅游點2
*/
private void goToTourismPoint2() {
goToPoint("旅游點2");
}
/**
* 到達旅游點1
*/
private void goToTourismPoint1() {
goToPoint("旅游點1");
}
/**
* 入住酒店
*/
private void goToHotel() {
goToPoint("酒店");
}
/**
* 出發(fā)點集合
*/
private void goToStartingPoint() {
goToPoint("出發(fā)點");
}
private int getRandomTime(){
int time = this.random.nextInt(400) + 100;
try {
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
return time;
}
private void goToPoint(String point){
try {
String name = Thread.currentThread().getName();
System.out.println(name + " 花了 " + getRandomTime() + " 時間才到了" + point);
cyclicBarrier.await();
} catch (Exception e) {
e.printStackTrace();
}
}
}
在每個旅游點,每個人旅游所花的時間是隨機的,有些人玩的比較久一點,有些則走馬觀花,拍拍照就完事了
再寫一個測試類,讓一群小朋友去旅游吧
public class TestMain {
public static void main(String[] args) {
String name = "明剛紅麗黑白";
CyclicBarrier cyclicBarrier = new CyclicBarrier(name.length(), new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() +
" 清點人數(shù),1,2,3...,ok,人到齊了,準備出發(fā)..... go go go....");
}
});
List tourismThread = new ArrayList<>();
for (char ch : name.toCharArray()){
tourismThread.add(new Thread(new TourismRunnable(cyclicBarrier), "小" + ch));
}
for (Thread thread : tourismThread){
thread.start();
}
}
}
運行結(jié)果:
小剛 花了 131 時間才到了出發(fā)點
小黑 花了 237 時間才到了出發(fā)點
小麗 花了 250 時間才到了出發(fā)點
小紅 花了 335 時間才到了出發(fā)點
小明 花了 379 時間才到了出發(fā)點
小白 花了 398 時間才到了出發(fā)點
小白 清點人數(shù),1,2,3...,ok,人到齊了,準備出發(fā)..... go go go....
小紅 花了 128 時間才到了酒店
小剛 花了 156 時間才到了酒店
小黑 花了 240 時間才到了酒店
小白 花了 280 時間才到了酒店
小明 花了 492 時間才到了酒店
小麗 花了 499 時間才到了酒店
小麗 清點人數(shù),1,2,3...,ok,人到齊了,準備出發(fā)..... go go go....
小麗 花了 188 時間才到了旅游點1
小剛 花了 315 時間才到了旅游點1
小明 花了 374 時間才到了旅游點1
小白 花了 395 時間才到了旅游點1
小黑 花了 428 時間才到了旅游點1
小紅 花了 496 時間才到了旅游點1
小紅 清點人數(shù),1,2,3...,ok,人到齊了,準備出發(fā)..... go go go....
小明 花了 206 時間才到了旅游點2
小剛 花了 223 時間才到了旅游點2
小紅 花了 302 時間才到了旅游點2
小白 花了 308 時間才到了旅游點2
小黑 花了 317 時間才到了旅游點2
小麗 花了 400 時間才到了旅游點2
小麗 清點人數(shù),1,2,3...,ok,人到齊了,準備出發(fā)..... go go go....
小白 花了 100 時間才到了旅游點3
小麗 花了 132 時間才到了旅游點3
小紅 花了 157 時間才到了旅游點3
小黑 花了 165 時間才到了旅游點3
小剛 花了 375 時間才到了旅游點3
小明 花了 416 時間才到了旅游點3
小明 清點人數(shù),1,2,3...,ok,人到齊了,準備出發(fā)..... go go go....
小剛 花了 100 時間才到了飛機場,準備登機回家
小黑 花了 137 時間才到了飛機場,準備登機回家
小紅 花了 232 時間才到了飛機場,準備登機回家
小明 花了 260 時間才到了飛機場,準備登機回家
小麗 花了 264 時間才到了飛機場,準備登機回家
小白 花了 394 時間才到了飛機場,準備登機回家
小白 清點人數(shù),1,2,3...,ok,人到齊了,準備出發(fā)..... go go go....
ok, 運行結(jié)果一目了然,中途沒有落下任何一個人!CyclicBarrier這個類,還是比較容易使用的
打賞
如果覺得我的文章寫的還過得去的話,有錢就捧個錢場,沒錢給我捧個人場(幫我點贊或推薦一下)
