Java并發(fā)編程:CountDownLatch丙笋、CyclicBarrier和Semaphore
歡迎關(guān)注作者簡書
csdn傳送門
轉(zhuǎn)載:原文地址
??在java 1.5中,提供了一些非常有用的輔助類來幫助我們進行并發(fā)編程茉继,比如CountDownLatch,CyclicBarrier和Semaphore蚀乔,今天我們就來學習一下這三個輔助類的用法烁竭。
一.CountDownLatch用法
??CountDownLatch類位于java.util.concurrent包下,利用它可以實現(xiàn)類似計數(shù)器的功能吉挣。比如有一個任務A派撕,它要等待其他4個任務執(zhí)行完畢之后才能執(zhí)行,此時就可以利用CountDownLatch來實現(xiàn)這種功能了睬魂。
??CountDownLatch類只提供了一個構(gòu)造器:
public CountDownLatch(int count) { }; //參數(shù)count為計數(shù)值
然后下面這3個方法是CountDownLatch類中最重要的方法:
public void await() throws InterruptedException { }; //調(diào)用await()方法的線程會被掛起终吼,它會等待直到count值為0才繼續(xù)執(zhí)行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { }; //和await()類似,只不過等待一定的時間后count值還沒變?yōu)?的話就會繼續(xù)執(zhí)行
public void countDown() { }; //將count值減1
??下面看一個例子大家就清楚CountDownLatch的用法了:
public class Test {
public static void main(String[] args) {
final CountDownLatch latch = new CountDownLatch(2);
new Thread(){
public void run() {
try {
System.out.println("子線程"+Thread.currentThread().getName()+"正在執(zhí)行");
Thread.sleep(3000);
System.out.println("子線程"+Thread.currentThread().getName()+"執(zhí)行完畢");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
new Thread(){
public void run() {
try {
System.out.println("子線程"+Thread.currentThread().getName()+"正在執(zhí)行");
Thread.sleep(3000);
System.out.println("子線程"+Thread.currentThread().getName()+"執(zhí)行完畢");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
try {
System.out.println("等待2個子線程執(zhí)行完畢...");
latch.await();
System.out.println("2個子線程已經(jīng)執(zhí)行完畢");
System.out.println("繼續(xù)執(zhí)行主線程");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
執(zhí)行結(jié)果:
線程Thread-0正在執(zhí)行
線程Thread-1正在執(zhí)行
等待2個子線程執(zhí)行完畢...
線程Thread-0執(zhí)行完畢
線程Thread-1執(zhí)行完畢
2個子線程已經(jīng)執(zhí)行完畢
繼續(xù)執(zhí)行主線程
二.CyclicBarrier用法
??字面意思回環(huán)柵欄氯哮,通過它可以實現(xiàn)讓一組線程等待至某個狀態(tài)之后再全部同時執(zhí)行际跪。叫做回環(huán)是因為當所有等待線程都被釋放以后喉钢,CyclicBarrier可以被重用。我們暫且把這個狀態(tài)就叫做barrier幔戏,當調(diào)用await()方法之后,線程就處于barrier了税课。
??CyclicBarrier類位于java.util.concurrent包下,CyclicBarrier提供2個構(gòu)造器:
public CyclicBarrier(int parties, Runnable barrierAction) {
}
public CyclicBarrier(int parties) {
}
??參數(shù)parties指讓多少個線程或者任務等待至barrier狀態(tài)韩玩;參數(shù)barrierAction為當這些線程都達到barrier狀態(tài)時會執(zhí)行的內(nèi)容。
??然后CyclicBarrier中最重要的方法就是await方法找颓,它有2個重載版本:
public int await() throws InterruptedException, BrokenBarrierException { };
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };
??第一個版本比較常用合愈,用來掛起當前線程,直至所有線程都到達barrier狀態(tài)再同時執(zhí)行后續(xù)任務叮雳;
??第二個版本是讓這些線程等待至一定的時間帘不,如果還有線程沒有到達barrier狀態(tài)就直接讓到達barrier的線程執(zhí)行后續(xù)任務杨箭。
??下面舉幾個例子就明白了:
??假若有若干個線程都要進行寫數(shù)據(jù)操作,并且只有所有線程都完成寫數(shù)據(jù)操作之后,這些線程才能繼續(xù)做后面的事情辽狈,此時就可以利用CyclicBarrier了:
public class Test {
public static void main(String[] args) {
int N = 4;
CyclicBarrier barrier = new CyclicBarrier(N);
for(int i=0;i<N;i++)
new Writer(barrier).start();
}
static class Writer extends Thread{
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
System.out.println("線程"+Thread.currentThread().getName()+"正在寫入數(shù)據(jù)...");
try {
Thread.sleep(5000); //以睡眠來模擬寫入數(shù)據(jù)操作
System.out.println("線程"+Thread.currentThread().getName()+"寫入數(shù)據(jù)完畢刮萌,等待其他線程寫入完畢");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
}catch(BrokenBarrierException e){
e.printStackTrace();
}
System.out.println("所有線程寫入完畢娘扩,繼續(xù)處理其他任務...");
}
}
}
??執(zhí)行結(jié)果:
線程Thread-0正在寫入數(shù)據(jù)...
線程Thread-3正在寫入數(shù)據(jù)...
線程Thread-2正在寫入數(shù)據(jù)...
線程Thread-1正在寫入數(shù)據(jù)...
線程Thread-2寫入數(shù)據(jù)完畢,等待其他線程寫入完畢
線程Thread-0寫入數(shù)據(jù)完畢涮阔,等待其他線程寫入完畢
線程Thread-3寫入數(shù)據(jù)完畢灰殴,等待其他線程寫入完畢
線程Thread-1寫入數(shù)據(jù)完畢,等待其他線程寫入完畢
所有線程寫入完畢伟阔,繼續(xù)處理其他任務...
所有線程寫入完畢掰伸,繼續(xù)處理其他任務...
所有線程寫入完畢,繼續(xù)處理其他任務...
所有線程寫入完畢娃承,繼續(xù)處理其他任務...
??從上面輸出結(jié)果可以看出怕篷,每個寫入線程執(zhí)行完寫數(shù)據(jù)操作之后,就在等待其他線程寫入操作完畢梳猪。
??當所有線程線程寫入操作完畢之后蒸痹,所有線程就繼續(xù)進行后續(xù)的操作了。
??如果說想在所有線程寫入操作完之后匿沛,進行額外的其他操作可以為CyclicBarrier提供Runnable參數(shù):
public class Test {
public static void main(String[] args) {
int N = 4;
CyclicBarrier barrier = new CyclicBarrier(N,new Runnable() {
@Override
public void run() {
System.out.println("當前線程"+Thread.currentThread().getName());
}
});
for(int i=0;i<N;i++)
new Writer(barrier).start();
}
static class Writer extends Thread{
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
System.out.println("線程"+Thread.currentThread().getName()+"正在寫入數(shù)據(jù)...");
try {
Thread.sleep(5000); //以睡眠來模擬寫入數(shù)據(jù)操作
System.out.println("線程"+Thread.currentThread().getName()+"寫入數(shù)據(jù)完畢逃呼,等待其他線程寫入完畢");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
}catch(BrokenBarrierException e){
e.printStackTrace();
}
System.out.println("所有線程寫入完畢,繼續(xù)處理其他任務...");
}
}
}
??運行結(jié)果:
線程Thread-0正在寫入數(shù)據(jù)...
線程Thread-1正在寫入數(shù)據(jù)...
線程Thread-2正在寫入數(shù)據(jù)...
線程Thread-3正在寫入數(shù)據(jù)...
線程Thread-0寫入數(shù)據(jù)完畢苏揣,等待其他線程寫入完畢
線程Thread-1寫入數(shù)據(jù)完畢推姻,等待其他線程寫入完畢
線程Thread-2寫入數(shù)據(jù)完畢,等待其他線程寫入完畢
線程Thread-3寫入數(shù)據(jù)完畢吐葱,等待其他線程寫入完畢
當前線程Thread-3
所有線程寫入完畢校翔,繼續(xù)處理其他任務...
所有線程寫入完畢,繼續(xù)處理其他任務...
所有線程寫入完畢孟辑,繼續(xù)處理其他任務...
所有線程寫入完畢蔫敲,繼續(xù)處理其他任務...
??從結(jié)果可以看出,當四個線程都到達barrier狀態(tài)后貌虾,會從四個線程中選擇一個線程去執(zhí)行Runnable裙犹。
??下面看一下為await指定時間的效果:
public class Test {
public static void main(String[] args) {
int N = 4;
CyclicBarrier barrier = new CyclicBarrier(N);
for(int i=0;i<N;i++) {
if(i<N-1)
new Writer(barrier).start();
else {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Writer(barrier).start();
}
}
}
static class Writer extends Thread{
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
System.out.println("線程"+Thread.currentThread().getName()+"正在寫入數(shù)據(jù)...");
try {
Thread.sleep(5000); //以睡眠來模擬寫入數(shù)據(jù)操作
System.out.println("線程"+Thread.currentThread().getName()+"寫入數(shù)據(jù)完畢叶圃,等待其他線程寫入完畢");
try {
cyclicBarrier.await(2000, TimeUnit.MILLISECONDS);
} catch (TimeoutException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (InterruptedException e) {
e.printStackTrace();
}catch(BrokenBarrierException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"所有線程寫入完畢,繼續(xù)處理其他任務...");
}
}
}
??執(zhí)行結(jié)果:
線程Thread-0正在寫入數(shù)據(jù)...
線程Thread-2正在寫入數(shù)據(jù)...
線程Thread-1正在寫入數(shù)據(jù)...
線程Thread-2寫入數(shù)據(jù)完畢沉馆,等待其他線程寫入完畢
線程Thread-0寫入數(shù)據(jù)完畢德崭,等待其他線程寫入完畢
線程Thread-1寫入數(shù)據(jù)完畢眉厨,等待其他線程寫入完畢
線程Thread-3正在寫入數(shù)據(jù)...
java.util.concurrent.TimeoutException
Thread-1所有線程寫入完畢,繼續(xù)處理其他任務...
Thread-0所有線程寫入完畢缺猛,繼續(xù)處理其他任務...
at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
at java.util.concurrent.CyclicBarrier.await(Unknown Source)
at com.cxh.test1.Test$Writer.run(Test.java:58)
java.util.concurrent.BrokenBarrierException
at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
at java.util.concurrent.CyclicBarrier.await(Unknown Source)
at com.cxh.test1.Test$Writer.run(Test.java:58)
java.util.concurrent.BrokenBarrierException
at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
at java.util.concurrent.CyclicBarrier.await(Unknown Source)
at com.cxh.test1.Test$Writer.run(Test.java:58)
Thread-2所有線程寫入完畢荔燎,繼續(xù)處理其他任務...
java.util.concurrent.BrokenBarrierException
線程Thread-3寫入數(shù)據(jù)完畢,等待其他線程寫入完畢
at java.util.concurrent.CyclicBarrier.dowait(Unknown Source)
at java.util.concurrent.CyclicBarrier.await(Unknown Source)
at com.cxh.test1.Test$Writer.run(Test.java:58)
Thread-3所有線程寫入完畢琐簇,繼續(xù)處理其他任務...
??上面的代碼在main方法的for循環(huán)中座享,故意讓最后一個線程啟動延遲,因為在前面三個線程都達到barrier之后丈秩,等待了指定的時間發(fā)現(xiàn)第四個線程還沒有達到barrier淳衙,就拋出異常并繼續(xù)執(zhí)行后面的任務。
??另外CyclicBarrier是可以重用的肠牲,看下面這個例子:
public class Test {
public static void main(String[] args) {
int N = 4;
CyclicBarrier barrier = new CyclicBarrier(N);
for(int i=0;i<N;i++) {
new Writer(barrier).start();
}
try {
Thread.sleep(25000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("CyclicBarrier重用");
for(int i=0;i<N;i++) {
new Writer(barrier).start();
}
}
static class Writer extends Thread{
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
System.out.println("線程"+Thread.currentThread().getName()+"正在寫入數(shù)據(jù)...");
try {
Thread.sleep(5000); //以睡眠來模擬寫入數(shù)據(jù)操作
System.out.println("線程"+Thread.currentThread().getName()+"寫入數(shù)據(jù)完畢缀雳,等待其他線程寫入完畢");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
}catch(BrokenBarrierException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"所有線程寫入完畢梢睛,繼續(xù)處理其他任務...");
}
}
}
??執(zhí)行結(jié)果:
線程Thread-0正在寫入數(shù)據(jù)...
線程Thread-1正在寫入數(shù)據(jù)...
線程Thread-3正在寫入數(shù)據(jù)...
線程Thread-2正在寫入數(shù)據(jù)...
線程Thread-1寫入數(shù)據(jù)完畢绝葡,等待其他線程寫入完畢
線程Thread-3寫入數(shù)據(jù)完畢,等待其他線程寫入完畢
線程Thread-2寫入數(shù)據(jù)完畢挤牛,等待其他線程寫入完畢
線程Thread-0寫入數(shù)據(jù)完畢墓赴,等待其他線程寫入完畢
Thread-0所有線程寫入完畢,繼續(xù)處理其他任務...
Thread-3所有線程寫入完畢诫硕,繼續(xù)處理其他任務...
Thread-1所有線程寫入完畢章办,繼續(xù)處理其他任務...
Thread-2所有線程寫入完畢滨彻,繼續(xù)處理其他任務...
CyclicBarrier重用
線程Thread-4正在寫入數(shù)據(jù)...
線程Thread-5正在寫入數(shù)據(jù)...
線程Thread-6正在寫入數(shù)據(jù)...
線程Thread-7正在寫入數(shù)據(jù)...
線程Thread-7寫入數(shù)據(jù)完畢挪蹭,等待其他線程寫入完畢
線程Thread-5寫入數(shù)據(jù)完畢,等待其他線程寫入完畢
線程Thread-6寫入數(shù)據(jù)完畢辜羊,等待其他線程寫入完畢
線程Thread-4寫入數(shù)據(jù)完畢词顾,等待其他線程寫入完畢
Thread-4所有線程寫入完畢,繼續(xù)處理其他任務...
Thread-5所有線程寫入完畢昔驱,繼續(xù)處理其他任務...
Thread-6所有線程寫入完畢上忍,繼續(xù)處理其他任務...
Thread-7所有線程寫入完畢,繼續(xù)處理其他任務...
??從執(zhí)行結(jié)果可以看出萌衬,在初次的4個線程越過barrier狀態(tài)后它抱,又可以用來進行新一輪的使用。而CountDownLatch無法進行重復使用混移。
三.Semaphore用法
??Semaphore翻譯成字面意思為 信號量侮穿,Semaphore可以控同時訪問的線程個數(shù)亲茅,通過 acquire() 獲取一個許可,如果沒有就等待克锣,而 release() 釋放一個許可。
??Semaphore類位于java.util.concurrent包下验残,它提供了2個構(gòu)造器:
public Semaphore(int permits) { //參數(shù)permits表示許可數(shù)目巾乳,即同時可以允許多少線程進行訪問
sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) { //這個多了一個參數(shù)fair表示是否是公平的,即等待時間越久的越先獲取許可
sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}
??下面說一下Semaphore類中比較重要的幾個方法氨鹏,首先是acquire()喻犁、release()方法:
public void acquire() throws InterruptedException { } //獲取一個許可
public void acquire(int permits) throws InterruptedException { } //獲取permits個許可
public void release() { } //釋放一個許可
public void release(int permits) { } //釋放permits個許可
??acquire()用來獲取一個許可何缓,若無許可能夠獲得,則會一直等待传轰,直到獲得許可谷婆。
??release()用來釋放許可。注意期贫,在釋放許可之前异袄,必須先獲獲得許可。
??這4個方法都會被阻塞封孙,如果想立即得到執(zhí)行結(jié)果讽营,可以使用下面幾個方法:
public boolean tryAcquire() { }; //嘗試獲取一個許可,若獲取成功膜蠢,則立即返回true莉兰,若獲取失敗,則立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { }; //嘗試獲取一個許可贪惹,若在指定的時間內(nèi)獲取成功寂嘉,則立即返回true枫绅,否則則立即返回false
public boolean tryAcquire(int permits) { }; //嘗試獲取permits個許可并淋,若獲取成功珍昨,則立即返回true,若獲取失敗兔毙,則立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //嘗試獲取permits個許可兄春,若在指定的時間內(nèi)獲取成功,則立即返回true哑姚,否則則立即返回false
??另外還可以通過availablePermits()方法得到可用的許可數(shù)目芜茵。
??下面通過一個例子來看一下Semaphore的具體使用:
??假若一個工廠有5臺機器,但是有8個工人绞佩,一臺機器同時只能被一個工人使用蒸辆,只有使用完了,其他工人才能繼續(xù)使用谆奥。那么我們就可以通過Semaphore來實現(xiàn):
public class Test {
public static void main(String[] args) {
int N = 8; //工人數(shù)
Semaphore semaphore = new Semaphore(5); //機器數(shù)目
for(int i=0;i<N;i++)
new Worker(i,semaphore).start();
}
static class Worker extends Thread{
private int num;
private Semaphore semaphore;
public Worker(int num,Semaphore semaphore){
this.num = num;
this.semaphore = semaphore;
}
@Override
public void run() {
try {
semaphore.acquire();
System.out.println("工人"+this.num+"占用一個機器在生產(chǎn)...");
Thread.sleep(2000);
System.out.println("工人"+this.num+"釋放出機器");
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
??執(zhí)行結(jié)果:
工人0占用一個機器在生產(chǎn)...
工人1占用一個機器在生產(chǎn)...
工人2占用一個機器在生產(chǎn)...
工人4占用一個機器在生產(chǎn)...
工人5占用一個機器在生產(chǎn)...
工人0釋放出機器
工人2釋放出機器
工人3占用一個機器在生產(chǎn)...
工人7占用一個機器在生產(chǎn)...
工人4釋放出機器
工人5釋放出機器
工人1釋放出機器
工人6占用一個機器在生產(chǎn)...
工人3釋放出機器
工人7釋放出機器
工人6釋放出機器
??下面對上面說的三個輔助類進行一個總結(jié):
1)CountDownLatch和CyclicBarrier都能夠?qū)崿F(xiàn)線程之間的等待酸些,只不過它們側(cè)重點不同:
CountDownLatch一般用于某個線程A等待若干個其他線程執(zhí)行完任務之后魄懂,它才執(zhí)行闯第;
而CyclicBarrier一般用于一組線程互相等待至某個狀態(tài),然后這一組線程再同時執(zhí)行填帽;
另外,CountDownLatch是不能夠重用的篡腌,而CyclicBarrier是可以重用的嘹悼。
2)Semaphore其實和鎖有點類似,它一般用于控制對某組資源的訪問權(quán)限其监。
??參考資料:
??《Java編程思想》
??http://www.itzhai.com/the-introduction-and-use-of-a-countdownlatch.html
??http://leaver.me/archives/3220.html
??http://developer.51cto.com/art/201403/432095.htm
??http://blog.csdn.net/yanhandle/article/details/9016329
??http://blog.csdn.net/cutesource/article/details/5780740
??http://www.cnblogs.com/whgw/archive/2011/09/29/2195555.html
歡迎加入Java猿社區(qū)缀台!
免費領(lǐng)取我歷年收集的所有學習資料哦膛腐!