最近在做一个程序的 时候遇到了这样的情况,在 主类中需要执行一些操作,同时主类会启动几个线程,在这些线程执行前和执行后都会一系列的操作。因此就用到了CountDownLatch类。CountDownLatch是一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。
下边是一个例子:
import mulithread.CountDownLatch;
class Driver {
public static void main(String []args) throws InterruptedException {
CountDownLatch startSignal = new CountDownLatch(1,"startsignal");
CountDownLatch doneSignal = new CountDownLatch(2,"endsignal");
for (int i = 0; i < 2; ++i)
new Thread(new Worker(startSignal, doneSignal,i)).start();// create and start threads
Thread.sleep(3000);
System.out.println("don't let run yet"); //don't let run yet
startSignal.countDown(); //let all threads proceed
doneSignal.await(); // wait for all to finish
System.out.println("wait for all to finish");
}
}
import mulithread.CountDownLatch;
class Worker implements Runnable {
private final CountDownLatch startSignal;
private final CountDownLatch doneSignal;
private int threadid;
Worker(CountDownLatch startSignal, CountDownLatch doneSignal,int threadid) {
this.startSignal = startSignal;
this.doneSignal = doneSignal;
this.threadid=threadid;
}
public void run() {
try {
System.out.println(threadid+"before process");
startSignal.await();//所有调用 await 的线程都一直在入口处等待
doWork();
doneSignal.countDown();
System.out.println(threadid+"after process");
} catch (InterruptedException ex) {
}
}
void doWork() {
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadid+"runing----------");
}
}
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
public class CountDownLatch {
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
Sync(int count) {
setState(count);
}
int getCount() {
return getState();
}
public int tryAcquireShared(int acquires) {
return getState() == 0? 1 : -1;
}
public boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}
private String name;
private final Sync sync;
public CountDownLatch(int count,String name) {
this.name=name;
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
System.out.println(name+" await invoked!"+getCount());
}
public boolean await(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
public void countDown() {
sync.releaseShared(1);
System.out.println(name+" count down invoked!"+getCount());
}
public long getCount() {
return sync.getCount();
}
public String toString() {
return super.toString() + "[Count = " + sync.getCount() + "]";
}
}
注意,有三个类,其中Driver是主类,Worker类是要工作时候用到的线程,CountDownLatch类值从java源代码抠出来的,只是做了一些状态输出工作。在这个例子中,有两个工作线程,所有的线程在工作之前(dowork方法完成工作任务)startSignal的await()方法会一直阻塞,直到主类中startSignal的countDown()执行之后才会执行。 同样的,在所有工作完成之前,主类中doneSignal的await()方法会一直阻塞,一直到doneSignal的所有线程的 countdown方法会被调用,使得计数器的值递减,从而后边的代码才会执行。这个例子其实简单而言描述这样一个场景:主类中如果有几个线程,但是这些线程又必须在主类中的一些操作完成之前才可以执行,那么就可以把代码放在主类的startSignal的countdown()方法之上,同样,如果想要在所有线程执行之后,做一些工作,那么就可以把代码放在doneSignal的await()方法之后执行。至于CountDownLatch 中的参数,其实就是计数器的值,看你的具体需求情况啦!