CountDownLatch
CountDownLatch從字面意思上來看，它是一個向下計數鎖，可以用來進行線程間的調度，主要方法如下：
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public boolean await(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
public void countDown() {
sync.releaseShared(1);
}
public long getCount() {
return sync.getCount();
}
構造函數只有一個，接受一個整數證，作為該對象的初始數值。方法也很簡單：
-
await()進入阻塞狀態，直到count為0為止 -
boolean await(long timeout, TimeUnit unit)同上，但是可以指定超時時間，超時返回false -
void countDown()計數減1 -
public long getCount()獲取當前計數
使用方法也非常簡單：
final CountDownLatch latch = new CountDownLatch(3);
new Thread(new Runnable() {
@Override
public void run() {
for (int i =0; i<5; i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
latch.countDown();
System.out.println("current count: " + latch.getCount());
}
}
}).start();
new Thread(new Runnable(){
@Override
public void run() {
try {
latch.await();
System.out.println("latch released.....");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
//執行結果：
current count: 2
current count: 1
latch released.....
current count: 0
current count: 0
current count: 0
CyclicBarrier
CyclicBarrier意思是回環柵欄，它的作用是為當前線程設置一個柵欄，掛起當前線程，直到掛起的線程數達到指定數量時才一起放行。Cyclic的意思是說，在放行以后，柵欄是可以被重復使用的。
主要方法如下：
public CyclicBarrier(int parties, Runnable barrierAction) {
if (parties <= 0) throw new IllegalArgumentException();
this.parties = parties;
this.count = parties;
this.barrierCommand = barrierAction;
}
public CyclicBarrier(int parties) {
this(parties, null);
}
public int await() throws InterruptedException, BrokenBarrierException {
}
public int await(long timeout, TimeUnit unit)
throws InterruptedException,
BrokenBarrierException,
TimeoutException {
return dowait(true, unit.toNanos(timeout));
}
public int getNumberWaiting() {
}
public int getParties() {
return parties;
}
-
CyclicBarrier(int parties, Runnable barrierAction)整數parties指定該barrier需要掛起的線程數，barrierAction表示barrier放行以后執行的動作，選定任意一個線程執行 -
int await()進入掛起狀態，返回值為剩余的線程數。可以被打斷或者調用reset方法拋出異常來終止掛起狀態，但是reset方法不建議使用，會導致不同線程間調度變得極為復雜。 -
int await(long timeout, TimeUnit unit)同上 -
int getNumberWaiting()獲取當前掛起的線程數 -
int getParties()獲取指定的線程數
下邊是簡單的例子：
final CyclicBarrier barrier = new CyclicBarrier(3, new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " execute barrier runnable.");
}
});
for(int i = 0; i < 5; i++){
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() + " index: " + barrier.await());
} catch (BrokenBarrierException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " start...");
}
},("T"+ i)).start();
}
}
執行結果如下：
T2 execute barrier runnable. //放行以后執行barrier指定的任務
T2 index: 0//T2 是最后開啟的線程，返回值為0表示barrier達到放行條件
T2 start...
T0 index: 2//T0 是第一個開啟的線程，返回值為2表示barrier還需要掛起兩個線程才能放行
T0 start...
T1 index: 1//T1 是第二個開啟的線程，返回值為1表示barrier還需要掛起1個線程才能放行
T1 start...
//此時還有兩個線程處于掛起狀態
Semaphore
Semaphore是信號量的意思，它更像是一種可以指定持有數量的鎖，該鎖的持有對象滿足數量之后，其他要獲取鎖的對象只能等待其他對象釋放。
它的主要方法如下：
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public void acquire(int permits) throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireSharedInterruptibly(permits);
}
public void acquireUninterruptibly() {
sync.acquireShared(1);
}
public void release() {
sync.releaseShared(1);
}
public void release(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}
public boolean tryAcquire() {
return sync.nonfairTryAcquireShared(1) >= 0;
}
-
Semaphore(int permits)指定持有者數量 -
Semaphore(int permits, boolean fair)可以指定是否實現為公平鎖 -
acquire()獲取1個信號量 -
acquire(int permits)獲取指定的信號量數量 -
acquireUninterruptibly()等待狀態不能被打斷 -
release()釋放信號量 -
release(int permits)釋放指定數量的信號量 -
boolean tryAcquire()嘗試獲取信號量，不阻塞，直接返回，false表示獲取失敗
