溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
最近一直整并發這塊東西，順便寫點Java并發的例子，給大家做個分享，也強化下自己記憶，如果有什么錯誤或者不當的地方，歡迎大家斧正。
CyclicBarrier是一種多線程并發控制實用工具，和CountDownLatch非常類似，它也可以實現線程間的計數等待，但是它的功能比CountDownLatch更加復雜且強大。
CyclicBarrier的介紹
CyclicBarrier 的字面意思是可循環（Cyclic）使用的屏障（Barrier）。它要做的事情是，讓一組線程到達一個屏障（也可以叫同步點）時被阻塞，直到最后一個線程到達屏障時，屏障才會開門，所有被屏障攔截的線程才會繼續干活。線程進入屏障通過CyclicBarrier的await()方法。
CyclicBarrier默認的構造方法是CyclicBarrier(int parties)，其參數表示屏障攔截的線程數量，每個線程調用await方法告訴CyclicBarrier我已經到達了屏障，然后當前線程被阻塞。
CyclicBarrier還提供一個更高級的構造函數CyclicBarrier(int parties, Runnable barrierAction)，用于在線程到達屏障時，優先執行barrierAction這個Runnable對象，方便處理更復雜的業務場景。
public CyclicBarrier(int parties) {
this(parties, null);
}
public int getParties() {
return parties;
}
實現原理：在CyclicBarrier的內部定義了一個Lock對象，每當一個線程調用CyclicBarrier的await方法時，將剩余攔截的線程數減1，然后判斷剩余攔截數是否為0，如果不是，進入Lock對象的條件隊列等待。如果是，執行barrierAction對象的Runnable方法，然后將鎖的條件隊列中的所有線程放入鎖等待隊列中，這些線程會依次的獲取鎖、釋放鎖，接著先從await方法返回，再從CyclicBarrier的await方法中返回。
CyclicBarrier主要用于一組線程之間的相互等待，而CountDownLatch一般用于一組線程等待另一組些線程。實際上可以通過CountDownLatch的countDown()和await()來實現CyclicBarrier的功能。即 CountDownLatch中的countDown()+await() = CyclicBarrier中的await()。注意：在一個線程中先調用countDown()，然后調用await()。
構造函數CyclicBarrier可以理解為循環柵欄，這個計數器可以反復使用。比如，假設我們將計數器設置為10，那么湊齊第一批10個線程后，計數器就會歸零，然后接著湊齊下一批10個線程，這就是它的內在含義。
LOL和王者榮耀的玩家很多，許多人應該都有打大龍的經歷，話說前期大家打算一起去偷大龍，由于前期大家都比較弱，需要五個人都齊了才能打大龍，這樣程序該如何實現呢？本人很菜，開始我的代碼是這么寫的（哈哈大家不要糾結我的時間）：
public class KillDragon {
/**
* 模擬打野去打大龍
*/
public static void dayePlayDragon(){
System.out.println("打野在去打大龍的路上，需要10s");
}
/**
* 模擬上單去打大龍
*/
public static void shangdanPlayDragon(){
System.out.println("上單在去打大龍的路上，需要10s");
}
/**
* 模擬中單去打大龍
*/
public static void zhongdanPlayDragon(){
System.out.println("中單在去打大龍的路上，需要10s");
}
/**
* 模擬ADC和輔助去打大龍
*/
public static void adcAndFuzhuPlayDragon(){
System.out.println("ADC和輔助在去打大龍的路上，需要10s");
}
/**
* 模擬大家一起去打大龍
*/
public static void killDragon()
{
System.out.println("打大龍...");
}
public static void main(String[] args)
{
dayePlayDragon();
shangdanPlayDragon();
zhongdanPlayDragon();
adcAndFuzhuPlayDragon();
killDragon();
}
結果如下：
打野在去打大龍的路上，需要10s 上單在去打大龍的路上，需要10s 中單在去打大龍的路上，需要10s ADC和輔助在去打大龍的路上，需要10s 打大龍...
這完了，大家在路上的時間就花了40s了，顯然是錯誤的。要是都這么干，對方把你塔都要偷光了。不行得改進下，怎么改呢，多線程并發執行，如是我改成了下面這樣的，用volatile關鍵字。
private static volatile int i = 4;
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
long start = System.currentTimeMillis();
while (i!=0){
}
while (i==0) {
killDragon();
i--;
long t = System.currentTimeMillis() - start;
System.out.println("總共耗時："+t+"毫秒");
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
dayePlayDragon();
try {
Thread.sleep(10000);
i--;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
shangdanPlayDragon();
try {
Thread.sleep(10000);
i--;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
zhongdanPlayDragon();
try {
Thread.sleep(10000);
i--;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
adcAndFuzhuPlayDragon();
try {
Thread.sleep(10000);
i--;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
結果如下：
打野在去打大龍的路上，需要10s 上單在去打大龍的路上，需要10s 中單在去打大龍的路上，需要10s ADC和輔助在去打大龍的路上，需要10s 打大龍... 總共耗時：10005毫秒
結果似乎還不錯，但是處理起來實在是有點麻煩，需要 while (i!=0)一直在那循環著。這時候學到了用 CyclicBarrier來處理，代碼如下:
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(5);
new Thread(new Runnable() {
@Override
public void run() {
long start = System.currentTimeMillis();
try {
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
killDragon();
long t = System.currentTimeMillis() - start;
System.out.println("總共耗時："+t+"毫秒");
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
dayePlayDragon();
try {
Thread.sleep(10000);
barrier.await();
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
shangdanPlayDragon();
try {
Thread.sleep(10000);
barrier.await();
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
zhongdanPlayDragon();
try {
Thread.sleep(10000);
barrier.await();
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
adcAndFuzhuPlayDragon();
try {
Thread.sleep(10000);
barrier.await();
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
}
大家都沒到達之前都等待，結果如下：
打野在去打大龍的路上，需要10s 上單在去打大龍的路上，需要10s 中單在去打大龍的路上，需要10s ADC和輔助在去打大龍的路上，需要10s 打大龍... 總共耗時：10002毫秒
CyclicBarrier相當于線程的計數器：
CyclicBarrier初始化時規定一個數目，然后計算調用了CyclicBarrier.await()進入等待的線程數。當線程數達到了這個數目時，所有進入等待狀態的線程被喚醒并繼續。
CyclicBarrier就象它名字的意思一樣，可看成是個障礙， 所有的線程必須到齊后才能一起通過這個障礙。
CyclicBarrier初始時還可帶一個Runnable的參數， 此Runnable任務在CyclicBarrier的數目達到后，所有其它線程被喚醒前被執行。
當然這樣使用CyclicBarrier和使用CountDownLatch是沒什么區別的，正如前文所說的CyclicBarrier的功能更加的復雜且強大。給大家看一個《實戰Java高并發程序設計》一書上的一個例子。
比如：司令下達命令，要求10個士兵去一起完成一項任務。這時，就會要求10個士兵先集合報道，接著，一起雄赳赳氣昂昂地去執行任務。當10個士兵都執行完了任務，那么司機就可以對外宣稱，任務完成。相比CountDownLatch，CyclicBarrier可以接受一個參數作為BarrierAction。所謂的BarrierAction就是當計數器一次計數完成后，系統會執行的動作。如下構造函數，其中，parties表示技術總數，也就是參與的線程總數。
public CyclicBarrier(int parties, Runnable barrierAction)
下面示例演示了上述任務場景
public class CyclicBarrierDemo {
public static class Soldier implements Runnable {
private String soldier;
private final CyclicBarrier cyclicBarrier;
public Soldier(CyclicBarrier cyclicBarrier, String soldier) {
this.soldier = soldier;
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
try {
cyclicBarrier.await();
doWork();
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
void doWork() {
try {
Thread.sleep(Math.abs(new Random().nextInt() % 10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(soldier + ":任務完成");
}
}
public static class BarrierRun implements Runnable {
boolean flag;
int N;
public BarrierRun(boolean flag, int N) {
this.flag = flag;
this.N = N;
}
@Override
public void run() {
if (flag) {
System.out.println("司令:[士兵" + N + "個,任務完成!");
} else {
System.out.println("司令:[士兵" + N + "個,集合完畢!");
flag = true;
}
}
}
public static void main(String args[]) {
final int N = 10;
Thread[] allSoldier = new Thread[N];
boolean flag = false;
CyclicBarrier cyclicBarrier = new CyclicBarrier(N, new BarrierRun(flag, N));
System.out.println("集合隊伍!");
for (int i = 0; i < N; i++) {
System.out.println("士兵" + i + "報道!");
allSoldier[i] = new Thread(new Soldier(cyclicBarrier, "士兵" + i));
allSoldier[i].start();
}
}
}
執行結果如下：
集合隊伍! 士兵0報道! 士兵1報道! 士兵2報道! 士兵3報道! 士兵4報道! 士兵5報道! 士兵6報道! 士兵7報道! 士兵8報道! 士兵9報道! 司令:[士兵10個,集合完畢! 士兵0:任務完成 士兵2:任務完成 士兵9:任務完成 士兵3:任務完成 士兵7:任務完成 士兵8:任務完成 士兵1:任務完成 士兵4:任務完成 士兵5:任務完成 士兵6:任務完成 司令:[士兵10個,任務完成!
總結
以上就是本文關于Java并發實例之CyclicBarrier的使用的全部內容，希望對大家有所幫助。感興趣的朋友可以繼續參閱本站：
Javaweb應用使用限流處理大量的并發請求詳解
java并發學習之BlockingQueue實現生產者消費者詳解
Java系統的高并發解決方法詳解
如有不足之處，歡迎留言指出。期待您的寶貴意見！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
