实战Java高并发程序设计之CountDownLatch

CountDownLatch:一个倒数计时器.

这个工具类通常用来控制线程等待,它可以让某一个线程等待直到计时结束,再开始执行.

CountDownLatch允许一个或多个线程等待直到在其他线程中执行的一组操作

如上图所示:主线程会在零界线上等待,检查任务会分别执行,当所有的任务全部都到达零界点以后,主线程才能继续往下执行

基本用法:

CountDownLatch是一个多功能的同步工具，可用于多种用途.

1.如果count初始化为1,它可以作为一个开/关锁存或者是门:所有调用await方法的线程都将一直等到到一个线程调用countDown,将count变成0
2.如果count初始化为n,它可以使一个线程等待,直到N个线程完成某些行为或者某个行为被完成N次

第二种情况分析:

使用Runnable描述每个部分，Runnable执行该部分并在锁存器上倒计时，并将所有Runnables排队到执行程序。
  当所有子部件完成时，协调线程将能够通过等待

伪代码:

class Driver { // ...
	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(int i) { 
		//what do you want to do...
	}
}

源码分析:
CountDownLatch也是使用AQS的状态来控制count

/**
     * CountDownLatch的内部类.用 AQS状态来表示计数
     */
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

        Sync(int count) {
            setState(count);
        }

        int getCount() {
            return getState();
        }

        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }

        protected 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;
            }
        }
    }

构造器:

CountDownLatch 初始化的时候必须要给一个count

    /**
     * 构造器
     *
     */
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

await方法:

 await方法在当前的count到达0之前会一直阻塞,当count为0以后,所有的等待的线程都会被释放,并且随后任何的调用await方法都将立即返回
 这是一次性的现象---count不能被重置.如果你想重置count的话,请考虑CyclicBarrier类

    /**
     * 
     *  如果当前计数为零，则此方法立即返回
     *
     *	如果当前计数大于零，则当前线程将被禁用以进行线程调度，并处于休眠状态，直至发生两件事情之一
     *	1.count变成0
     *  2.当前线程被中断
     *
     */
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    /**
     * 同上
     * 指定时间过后直接返回
     */
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

countDown方法:

为了保持内存一致性,在计数器到达0之前,对应的countDown方法都将在await方法之前返回(happen-before原则)

    /**
     * 减少锁存器的计数，如果计数达到零，释放所有等待的线程
     * 如果当前计数大于零，则它将递减。 如果新计数为零，则所有等待的线程都将被重新启用以进行线程调度
     * 如果当前计数等于零，那么没有任何反应
     */
    public void countDown() {
        sync.releaseShared(1);
    }

getCount方法

    /**
     * 返回当前计数.
     * 该方法通常用于调试和测试
     */
    public long getCount() {
        return sync.getCount();
    }

书中demo:

public class CountDownLatchDemo implements Runnable {
    static final CountDownLatch end = new CountDownLatch(10);
    static final CountDownLatchDemo demo=new CountDownLatchDemo();
    @Override
    public void run() {
        try {
            //模拟任务检查
            Thread.sleep(new Random().nextInt(10)*1000);
            System.out.println("check complete");
            end.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newFixedThreadPool(10);
        for(int i=0;i<10;i++){
            exec.submit(demo);
        }
        //等待检查
        end.await();   //等待所有的线程都完成以后才会取消等待,主线程继续
        //发射火箭
        System.out.println("Fire!");
        exec.shutdown();
    }
}