2. 程式人生 > >java併發之CyclicBarrier（障礙器）

java併發之CyclicBarrier（障礙器）

阿新 • • 發佈：2019-01-06

CyclicBarrier是一個同步輔助類，它允許一組執行緒互相等待，直到到達某個公共屏障點 (common barrier point)。在涉及一組固定大小的執行緒的程式中，這些執行緒必須不時地互相等待，此時 CyclicBarrier 很有用。因為該 barrier 在釋放等待執行緒後可以重用，所以稱它為迴圈 的 barrier。CyclicBarrier 支援一個可選的 Runnable 命令，在一組執行緒中的最後一個執行緒到達之後（但在釋放所有執行緒之前），該命令只在每個屏障點執行一次。若在繼續所有參與執行緒之前更新共享狀態，此屏障操作 很有用。 

//設定parties、count及barrierCommand屬性。   
CyclicBarrier(int):   
  
//當await的數量到達了設定的數量後，首先執行該Runnable物件。   
CyclicBarrier(int,Runnable):   
  
//通知barrier已完成執行緒   
await():


適用情況：你希望建立一組任務，它們併發地執行工作，另外的一個任務在這一組任務併發執行結束前一直阻塞等待，直到該組任務全部執行結束，這個任務才得以執行。這非常像CountDownLatch，只是CountDownLatch是隻觸發一次的事件，而CyclicBarrier可以多次重用。
    下面給出一個簡單的例項來說明其用法：

import java.util.concurrent.BrokenBarrierException;   
import java.util.concurrent.CyclicBarrier;    
public class CyclicBarrierTest {   
        public static void main(String[] args) {   
                //建立CyclicBarrier物件，  
                //並設定執行完一組5個執行緒的併發任務後，再執行MainTask任務  
                CyclicBarrier cb = new CyclicBarrier(5, new MainTask());   
                new SubTask("A", cb).start();   
                new SubTask("B", cb).start();   
                new SubTask("C", cb).start();   
                new SubTask("D", cb).start();   
                new SubTask("E", cb).start();  
        }   
}   
  
/**  
* 最後執行的任務 
*/   
class MainTask implements Runnable {   
        public void run() {   
                System.out.println("......執行最後的任務了......");   
        }   
}   
  
/**  
* 一組併發任務  
*/   
class SubTask extends Thread {   
        private String name;   
        private CyclicBarrier cb;   
  
        SubTask(String name, CyclicBarrier cb) {   
                this.name = name;   
                this.cb = cb;   
        }   
  
        public void run() {   
                System.out.println("[併發任務" + name + "]  開始執行");   
                for (int i = 0; i < 999999; i++) ;    //模擬耗時的任務   
                System.out.println("[併發任務" + name + "]  開始執行完畢，通知障礙器");   
                try {   
                        //每執行完一項任務就通知障礙器   
                        cb.await();   
                } catch (InterruptedException e) {   
                        e.printStackTrace();   
                } catch (BrokenBarrierException e) {   
                        e.printStackTrace();   
                }   
        }   
}
結果：

[併發任務A]  開始執行
[併發任務B]  開始執行
[併發任務B]  開始執行完畢，通知障礙器
[併發任務C]  開始執行
[併發任務C]  開始執行完畢，通知障礙器
[併發任務A]  開始執行完畢，通知障礙器
[併發任務D]  開始執行
[併發任務D]  開始執行完畢，通知障礙器
[併發任務E]  開始執行
[併發任務E]  開始執行完畢，通知障礙器
......終於要執行最後的任務了......

package com.gpl.concurrent;

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

public class CyclicBarrierTest2 {
	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final CyclicBarrier cb = new CyclicBarrier(3); // 三個執行緒同時到達
		for (int i = 0; i < 3; i++) {
			Runnable runnable = new Runnable() {
				public void run() {
					try {
						Thread.sleep((long) (Math.random() * 10000));
						System.out.println("執行緒"
								+ Thread.currentThread().getName()
								+ "即將到達集合地點1，當前已有"
								+ (cb.getNumberWaiting() + 1)
								+ "個已到達"
								+ (cb.getNumberWaiting() == 2 ? "都到齊了，繼續走啊"
										: "正在等候"));
						try {
							cb.await();
						} catch (BrokenBarrierException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						Thread.sleep((long) (Math.random() * 10000));
						System.out.println("執行緒"
								+ Thread.currentThread().getName()
								+ "即將到達集合地點2，當前已有"
								+ (cb.getNumberWaiting() + 1)
								+ "個已到達"
								+ (cb.getNumberWaiting() == 2 ? "都到齊了，繼續走啊"
										: "正在等候"));
						try {
							cb.await();
						} catch (BrokenBarrierException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						Thread.sleep((long) (Math.random() * 10000));
						System.out.println("執行緒"
								+ Thread.currentThread().getName()
								+ "即將到達集合地點3，當前已有"
								+ (cb.getNumberWaiting() + 1)
								+ "個已到達"
								+ (cb.getNumberWaiting() == 2 ? "都到齊了，繼續走啊"
										: "正在等候"));
						try {
							cb.await();
						} catch (BrokenBarrierException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			};
			service.execute(runnable);
		}
		service.shutdown();
	}
}
結果：

執行緒pool-1-thread-3即將到達集合地點1，當前已有1個已到達正在等候
執行緒pool-1-thread-2即將到達集合地點1，當前已有2個已到達正在等候
執行緒pool-1-thread-1即將到達集合地點1，當前已有3個已到達都到齊了，繼續走啊
執行緒pool-1-thread-2即將到達集合地點2，當前已有1個已到達正在等候
執行緒pool-1-thread-3即將到達集合地點2，當前已有2個已到達正在等候
執行緒pool-1-thread-1即將到達集合地點2，當前已有3個已到達都到齊了，繼續走啊
執行緒pool-1-thread-1即將到達集合地點3，當前已有1個已到達正在等候
執行緒pool-1-thread-3即將到達集合地點3，當前已有2個已到達正在等候
執行緒pool-1-thread-2即將到達集合地點3，當前已有3個已到達都到齊了，繼續走啊
執行緒pool-1-thread-2即將到達集合地點1，當前已有2個已到達正在等候
執行緒pool-1-thread-1即將到達集合地點1，當前已有3個已到達都到齊了，繼續走啊
執行緒pool-1-thread-2即將到達集合地點2，當前已有1個已到達正在等候
執行緒pool-1-thread-3即將到達集合地點2，當前已有2個已到達正在等候
執行緒pool-1-thread-1即將到達集合地點2，當前已有3個已到達都到齊了，繼續走啊
執行緒pool-1-thread-1即將到達集合地點3，當前已有1個已到達正在等候
執行緒pool-1-thread-3即將到達集合地點3，當前已有2個已到達正在等候
執行緒pool-1-thread-2即將到達集合地點3，當前已有3個已到達都到齊了，繼續走啊

等價的一個程式：

package com.gpl.concurrent;

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

public class CyclicBarrierTest3 {
	public static void main(String[] args){
		CyclicBarrier cb = new CyclicBarrier(3); // 三個執行緒同時到達
		 new SubTask1("A", cb).start();
		 new SubTask1("B", cb).start(); 
	     new SubTask1("C", cb).start();
	}
	 
}

class SubTask1 extends Thread { 
    private String name; 
    private CyclicBarrier cb; 

    SubTask1(String name, CyclicBarrier cb) { 
            this.name = name; 
            this.cb = cb; 
    } 

    public void run() { 
            //System.out.println("[併發任務" + name + "]  開始執行"); 
            //for (int i = 0; i < 999999; i++) ;    //模擬耗時的任務 
            
            try {
				Thread.sleep((long) (Math.random() * 10000));
				System.out.println("執行緒"+ Thread.currentThread().getName()+ "即將到達集合地點1，當前已有"
						+ (cb.getNumberWaiting() + 1)+ "個已到達"+ (cb.getNumberWaiting() == 2 ? "都到齊了，繼續走啊": "正在等候"));
				try { 
				        //每執行完一項任務就通知障礙器 
				        cb.await(); 
				} catch (InterruptedException e) { 
				        e.printStackTrace(); 
				} catch (BrokenBarrierException e) { 
				        e.printStackTrace(); 
				}Thread.sleep((long) (Math.random() * 10000));
				System.out.println("執行緒"
						+ Thread.currentThread().getName()
						+ "即將到達集合地點2，當前已有"
						+ (cb.getNumberWaiting() + 1)
						+ "個已到達"
						+ (cb.getNumberWaiting() == 2 ? "都到齊了，繼續走啊"
								: "正在等候"));
				try {
					cb.await();
				} catch (BrokenBarrierException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				Thread.sleep((long) (Math.random() * 10000));
				System.out.println("執行緒"
						+ Thread.currentThread().getName()
						+ "即將到達集合地點3，當前已有"
						+ (cb.getNumberWaiting() + 1)
						+ "個已到達"
						+ (cb.getNumberWaiting() == 2 ? "都到齊了，繼續走啊"
								: "正在等候"));
				try {
					cb.await();
				} catch (BrokenBarrierException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} 
    } 
}
結果：

執行緒Thread-0即將到達集合地點1，當前已有1個已到達正在等候
執行緒Thread-1即將到達集合地點1，當前已有2個已到達正在等候
執行緒Thread-2即將到達集合地點1，當前已有3個已到達都到齊了，繼續走啊
執行緒Thread-1即將到達集合地點2，當前已有1個已到達正在等候
執行緒Thread-0即將到達集合地點2，當前已有2個已到達正在等候
執行緒Thread-2即將到達集合地點2，當前已有3個已到達都到齊了，繼續走啊
執行緒Thread-0即將到達集合地點3，當前已有1個已到達正在等候
執行緒Thread-1即將到達集合地點3，當前已有2個已到達正在等候
執行緒Thread-2即將到達集合地點3，當前已有3個已到達都到齊了，繼續走啊

相關推薦

java併發之CyclicBarrier（障礙器）

CyclicBarrier是一個同步輔助類，它允許一組執行緒互相等待，直到到達某個公共屏障點 (common barrier point)。在涉及一組固定大小的執行緒的程式中，這些執行緒必須不時地互相等待，此時 CyclicBarrier 很有用。因為該 barrier

java併發之Semaphore（計數訊號量）

Semaphore一個計數訊號量。從概念上講，訊號量維護了一個許可集。如有必要，在許可可用前會阻塞每一個 acquire()，然後再獲取該許可。每個 release() 新增一個許可，從而可能釋放一個正在阻塞的獲取者。但是，不使用實際的許可物件，Semaphore 只對可用

Java學習之路（書籍推薦）

個人 分布式 方法 都是 操作 測試 對象 web編程 數據庫 一、基礎類 1、《Thinking in java》(閱讀2遍)，入門第一位是建立正確的概念 2、《Core Java》這本書更貼近實踐，更多API的介紹，同樣，更新也更頻繁。(可以選重點章節讀一下) 二、進階

java 併發之CyclicBarrier

什麼是CyclicBarrier 可以理解為迴圈柵欄,柵欄就是一種障礙物.假如我們將計數器設定為10,那麼湊齊第一批10個執行緒後,計數器就會歸零,然後接著湊齊下一批10個執行緒,這就是迴圈柵欄的含義. 構造器: public CyclicBarrier(int parties,

Java學習之路（基礎一）

基礎知識 關鍵字 (1)被Java語言賦予特定含義的單詞 (2)特點：全部小寫。 (3)注意事項： A:goto和const作為保留字存在。 B:類似於Notepad++這樣的高階記事本會對關鍵字有特殊顏色標記 識別符號

Java學習之路（轉） Java學習之路（書籍推薦）

Java學習之路（書籍推薦）   一、基礎類 1、《Thinking in java》(閱讀2遍)，入門第一位是建立正確的概念 2、《Core Java》這本書更貼近實踐，更多API的介紹，同樣，更新也更頻繁。(可以選重點章節讀一下) 二、進階類 1、

Java學習之路（基礎二）

Java製作幫助文件 幫助文件製作的基本語法格式： dos下：javadoc -d document -author -version ArrayTool.java 程式碼塊 用"{}" 包裹起來的程式碼都叫做程式碼塊。 常見有以下幾類： 區域性程式碼塊

併發：CyclicBarrier（同步屏障）。

CyclicBarrier的字面意思是可迴圈使用（Cyclic）的屏障（Barrier）。他要做的事情是，讓一組執行緒達到一個屏障（也可以叫同步點）時被阻塞，直到最後一個執行緒達到屏障時，屏障才會開門，所有屏障攔截的執行緒才會繼續執行。 CyclicBarrier簡介 CyclicBarri

Java基礎之—反射（非常重要）

package fanshe; import java.lang.reflect.Constructor; /* * 通過Class物件可以獲取某個類中的：構造方法、成員變數、成員方法；並訪問成員； * * 1.獲取構造方法： * 1).批量的方法： * public Constr

Java學習之方法（方法過載）

一、什麼是方法？ 　　在日常生活中，方法可以理解為要做某件事情，而採取的解決方法 　　比如：小明剛出家門，要去學校上課，這就面臨一個問題需要解決，小明應該怎麼去學校呢？有什麼解決辦法嗎？ 　　可以採用坐公交車或者走路又或者坐計程車的方法去學校，那麼，這種解決某件事情的辦法，就稱之為方法 　　在Java

Java基礎之反射（非常重要）

點選上方“Java團長”，選擇“置頂公眾號”技術文章第一時間送達！反射是框架設計的靈魂（使用的前

Java SE 高階開發之Java IO 之 File（檔案操作）

File檔案操作類 在Java.io包之中，File類是唯一一個與檔案本身操作(建立、刪除、取得資訊..)有關的程式類。 File類的基本使用 java.io.File類是一個普通的類，直接產生例項化物件即可。如果要例項化物件則需要使用到兩個構造方法：

java Map 之 排序（key,value）

一：起因： （1）現實中需要Map容器進行排序的情況很多很多：因為Map<key,value>鍵值對的儲存結構特別是HashMap的結構是非常優秀的，資料儲存就難免對其進行排序； （2）資料處理，只要用到對映關係的，離不開Map,這在資料處理中是非常實用的，而排

JAVA併發程式設計——Semaphore（訊號量）

控制併發執行緒數的Semaphore Semaphore（訊號量）是用來控制同時訪問特定資源的執行緒數量，它通過協調各個執行緒，以保證合理的使用公共資源。應用場景Semaphore可以用於做流量控制，特別是公用資源有限的應用場景，比如資料庫連線。假如有一個需求，

多執行緒庫SCoop應用 之 時鐘（計時器）

使用該庫的【時鐘（又叫：計時器）】功能，首先要做三件事： 第二：setup函式裡，呼叫mySCoop.start()命令 void setup() { mySCoop.start(); } 第三：loop函式裡，呼叫yield()命令 void

java架構之路-（設計模式）五種建立型模式之單例模式

　　設計模式自身一直不是很瞭解，但其實我們時刻都在使用這些設計模式的，java有23種設計模式和6大原則。 設計模式是一套被反覆使用、多數人知曉的、經過分類編目的、程式碼設計經驗的總結。使用設計模式是為了可重用程式碼、讓程式碼更容易被他人理解、保證程式碼可靠性、程式的重用性。 其中包含 建立型模式，共五種：單

java架構之路-（分散式zookeeper）zookeeper叢集配置和選舉機制詳解

　　上次部落格我們說了一下zookeeper的配置檔案，以及命令的使用https://www.cnblogs.com/cxiaocai/p/11597465.html。我們這次來說一下我們的zookeeper的叢集配置和java的API相關操作。 叢集： 　　一般情況下我們用zookeeper來做任務排程中心

java架構之路-（SpringMVC篇）SpringMVC主要流程原始碼解析（上）原始碼執行流程

　　做過web專案的小夥伴，對於SpringMVC，Struts2都是在熟悉不過了，再就是我們比較古老的servlet，我們先來複習一下我們的servlet生命週期。 servlet生命週期 1）初始化階段 　　當客戶端向 Servlet 容器發出 HTTP 請求要求訪問 Servlet 時，Servlet

java架構之路-（面試篇）JVM虛擬機器面試大全

　　下文連線比較多啊，都是我過整理的部落格，很多答案都在部落格裡有詳細說明，理解記憶是最紮實的記憶。而且我的答案不一定是最準確的，但是我的答案不會讓你失望，而且幾乎每個答案都是問題的擴充套件答案。 1.JVM記憶體模型 　　答：https://www.cnblogs.com/cxiaocai/p/114836

java架構之路-（面試篇）Mysql面試大全

　　說一下mysql比較巨集觀的面試，具體咋寫sql的這裡就不過多舉例了。後面我還會給出一個關於mysql面試優化的試題，這裡主要說的索引和B+Tree結構，很少提到我們的叢集配置優化方案。 1.索引是什麼？有什麼作用以及缺點 　　答：索引是對資料庫表中一列或多列的值進行排序的一種結構，使用索引可快速訪問資料