併發編程:CountDownLatch、CyclicBarrier和 Semaphore的用法
目錄
分享一下最近學過的幾種併發類的用法.
CountDownLatch用法
可以利用它實現類似計數器的功能。比如有一個任務A,它要等待其他若干個任務執行完畢之後才能執行,此時就可以利用CountDownLatch來實現這種功能了;也可以用來控制初始化操作,某個任務執行之前,必須初始化成功之後,才能進行操作,否則將一直阻塞。
類方法介紹:
public void await() throws InterruptedException { }; //調用await()方法的線程會被阻塞,它會等待直到count值爲0才繼續執行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { }; //和await()類似,只不過等待一定的時間後count值還沒變爲0的話就會繼續執行
public void countDown() { }; //將count值減1
例子程序範例:
public class CountDownLatchTest{
public static void main(String[] args) {
//創建
final CountDownLatch latch = new CountDownLatch(2);
new Thread(){
public void run() {
try {
System.out.println("子線程"+Thread.currentThread().getName()+"正在執行");
Thread.sleep(3000);
System.out.println("子線程"+Thread.currentThread().getName()+"執行完畢");
//一個任務執行完成,countDown一次
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
new Thread(){
public void run() {
try {
System.out.println("子線程"+Thread.currentThread().getName()+"正在執行");
Thread.sleep(3000);
System.out.println("子線程"+Thread.currentThread().getName()+"執行完畢");
//一個任務執行完成,countDown一次
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
try {
System.out.println("等待2個子線程執行完畢...");
//等待其他任務執行完成
latch.await();
System.out.println("2個子線程已經執行完畢");
System.out.println("繼續執行主線程");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
CyclicBarrier用法
字面意思迴環柵欄,通過它可以實現讓一組線程等待至某個狀態之後再全部同時執行。叫做迴環是因爲當所有等待線程都被釋放以後,CyclicBarrier可以被重用。我們暫且把這個狀態就叫做barrier,當調用await()方法之後,線程就處於barrier了;換句話說,就是控制多個任務在某種條件下,同時運行。
類方法介紹:
參數parties指讓多少個線程或者任務等待至barrier狀態;參數barrierAction爲當這些線程都達到barrier狀態時會執行的內容。
public CyclicBarrier(int parties, Runnable barrierAction) {
}
public CyclicBarrier(int parties) {
}
public int await() throws InterruptedException, BrokenBarrierException { };
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };
例子程序範例:
public class CyClicBarrierTest {
public static void main(String[] args) {
int N = 4;
//指定等待的線程個數
CyclicBarrier barrier = new CyclicBarrier(N);
for(int i=0;i<N;i++)
new Task(barrier).start();
}
//任務線程
static class Task extends Thread{
private CyclicBarrier cyclicBarrier;
public Task(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
System.out.println("線程"+Thread.currentThread().getName()+"正在進行準備操作...");
try {
Thread.sleep(5000);
System.out.println("線程"+Thread.currentThread().getName()+"準備完畢,等待其他任務準備完畢");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
}catch(BrokenBarrierException e){
e.printStackTrace();
}
System.out.println("所有線程準備完畢,任務繼續處理其他操作...");
}
}
}
如果說想在所有線程寫入操作完之後,進行額外的其他操作可以爲CyclicBarrier提供Runnable參數:
public class CyClicBarrierTest {
public static void main(String[] args) {
int N = 4;
//指定等待的線程個數
CyclicBarrier barrier = new CyclicBarrier(N,new Runnable({
@Override
public void run(){
System.out.println("所有任務已經準備好了,可以繼續執行其他操作了");
}
}));
for(int i=0;i<N;i++)
new Task(barrier).start();
}
//任務線程
static class Task extends Thread{
private CyclicBarrier cyclicBarrier;
public Task(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
System.out.println("線程"+Thread.currentThread().getName()+"正在進行準備操作...");
try {
Thread.sleep(5000);
System.out.println("線程"+Thread.currentThread().getName()+"準備完畢,等待其他任務準備完畢");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
}catch(BrokenBarrierException e){
e.printStackTrace();
}
System.out.println("所有線程準備完畢,任務繼續處理其他操作...");
}
}
}
Semaphore用法
Semaphore翻譯成字面意思爲 信號量,Semaphore可以控同時訪問的線程個數,通過 acquire() 獲取一個許可,如果沒有就等待,而 release() 釋放一個許可。
類方法介紹:
public Semaphore(int permits) { //參數permits表示許可數目,即同時可以允許多少線程進行訪問
sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) { //這個多了一個參數fair表示是否是公平的,即等待時間越久的越先獲取許可
sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}
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個方法都會被阻塞,如果想立即得到執行結果,可以使用下面幾個方法:
public boolean tryAcquire() { }; //嘗試獲取一個許可,若獲取成功,則立即返回true,若獲取失敗,則立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { }; //嘗試獲取一個許可,若在指定的時間內獲取成功,則立即返回true,否則則立即返回false
public boolean tryAcquire(int permits) { }; //嘗試獲取permits個許可,若獲取成功,則立即返回true,若獲取失敗,則立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //嘗試獲取permits個許可,若在指定的時間內獲取成功,則立即返回true,否則則立即返回false
例子程序範例:
假若一個工廠有5臺機器,但是有8個工人,一臺機器同時只能被一個工人使用,只有使用完了,其他工人才能繼續使用。那麼我們就可以通過Semaphore來實現:
public class SemaphoreTest {
public static void main(String[] args) {
int N = 8; //工人數
Semaphore semaphore = new Semaphore(5); //機器數目
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+"佔用一個機器在生產...");
Thread.sleep(2000);
System.out.println("工人"+this.num+"釋放出機器");
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
下面對上面說的三個輔助類進行一個總結:
1)CountDownLatch和CyclicBarrier都能夠實現線程之間的等待,只不過它們側重點不同:
CountDownLatch一般用於某個線程A等待若干個其他線程執行完任務之後,它才執行;
而CyclicBarrier一般用於一組線程互相等待至某個狀態,然後這一組線程再同時執行;
另外,CountDownLatch是不能夠重用的,而CyclicBarrier是可以重用的。
2)Semaphore其實和鎖有點類似,它一般用於控制對某組資源的訪問權限。