其实很早之前就有过这么个想法:比如有10个任务,其中有个任务A,A任务需要等待其他所有的任务完成后,再开始执行,这里每个任务都是在单独的线程完成,举个栗子:对Launcher类的App,需要对Android设备上的所有应用的入口信息处理,这个过程是相当长的,但是我们可以根据当前设备可用线程数,创建一定数量的线程,将入口处理分成多个任务单独处理,处理完后,一次性写入数据库.而写入出具库行为需要等待所有的图标处理完毕才执行,就是我刚才说的场景了,而CountDownLatch 正好可以满足这个场景的需要.
CountDownLatch就字面意思就是 倒计数锁存器,他可以让线程在CountDownLatch.await()处等待,直到其他线程调用CountDownLatch.countDown()时才换线在CountDownLatch.await()处等待的线程,这里面还有一个重要的点:CountDownLatch.countDown()必须调用N次, N就是创建CountDownLatch 时由构造器指定的值N.
这样的就可以达到这样的目的:①让某一个线程等待其他多个线程执行完毕后才开始执行②让多个线程等待某一个线程执行完毕后才开始执行.示例代码如下(官方代码):
- 在Driver准备好之前,其他的Worker都要等待
- 在其他Worker全部执行完之前,Driver等待
class Driver { // ...
void main() throws InterruptedException {
CountDownLatch startSignal = new CountDownLatch(1);
CountDownLatch doneSignal = new CountDownLatch(N);
for (int i = 0; i < N; ++i) // create and start threads
new Thread(new Worker(startSignal, doneSignal)).start();
doSomethingElse(); // don't let run yet
startSignal.countDown(); // let all threads proceed
doSomethingElse();
doneSignal.await(); // wait for all to finish
}
}
class Worker implements Runnable {
private final CountDownLatch startSignal;
private final CountDownLatch doneSignal;
Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
this.startSignal = startSignal;
this.doneSignal = doneSignal;
}
public void run() {
try {
startSignal.await();
doWork();
doneSignal.countDown();
} catch (InterruptedException ex) {} // return;
}
void doWork() { ... }
}
第二个用法就是将某个任务分成N个部分,然后执行,直到这N个任务完成后,主线程才会继续执行,与上面提到的2 描述很类似:
class Driver2 { // ...
void main() throws InterruptedException {
CountDownLatch doneSignal = new CountDownLatch(N);
Executor e = ...
for (int i = 0; i < N; ++i) // create and start threads
e.execute(new WorkerRunnable(doneSignal, i));
doneSignal.await(); // wait for all to finish
}
}
class WorkerRunnable implements Runnable {
private final CountDownLatch doneSignal;
private final int i;
WorkerRunnable(CountDownLatch doneSignal, int i) {
this.doneSignal = doneSignal;
this.i = i;
}
public void run() {
try {
doWork(i);
doneSignal.countDown();
} catch (InterruptedException ex) {} // return;
}
void doWork() { ... }
}
CyclicBarrier 就是周期性的屏障,他允许一组线程互相等待,直到所有的线程都到达屏障点.在固定数目的线程中,让线程互相等待,这一点非常有用,同时CycliBarrier还支持一个可选的 Runnable,允许在屏障点到达的最后一个线程执行这个可选的Runnable,比如下面的代码(官方地址):
class Solver {
final int N;
final float[][] data;
final CyclicBarrier barrier;
class Worker implements Runnable {
int myRow;
Worker(int row) { myRow = row; }
public void run() {
while (!done()) {
processRow(myRow);
try {
barrier.await();
} catch (InterruptedException ex) {
return;
} catch (BrokenBarrierException ex) {
return;
}
}
}
}
public Solver(float[][] matrix) {
data = matrix;
N = matrix.length;
Runnable barrierAction =
new Runnable() { public void run() { mergeRows(...); }};
barrier = new CyclicBarrier(N, barrierAction);
List<Thread> threads = new ArrayList<>(N);
for (int i = 0; i < N; i++) {
Thread thread = new Thread(new Worker(i));
threads.add(thread);
thread.start();
}
// wait until done
for (Thread thread : threads)
thread.join();
}
}
其中,每个Work线程处理每一行的数据,注意,我们的 new CyclicBarrier(N,barrierAction),其中N就是屏障点到达的次数,当每个线程调用barrier.await()时,线程在此处等待,当最后一个线程调用barrier.await(),也就是第N次调用时,该线程立即返回,然后执行barrierAction,然后其他等待的线程被一次唤醒!
如果barrierAction 不依赖于暂停的线程,也即等待最后一个线程调用barrier.await(),那么任何线程都可以在自己被恢复后执行barrierAction,为了实现这个目标,每个barrier.await()的调用都会返回到达线程的索引(也就是线程的等待索引,最后先等待的线程的barrier.await()返回是最大的(N -1),所以我们可以方便的选哪个线程来执行barrierAction!
关于更多CyclicBarrier 和CountDownLatch的详细信息,请见官网