（五）新类库的构件

CountDownLatch

public class CountDownLatch
extends Object

A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.

A CountDownLatch is initialized with a given count. The await methods block until the current count reaches zero due to invocations of the countDown() method, after which all waiting threads are released and any subsequent invocations of await return immediately. This is a one-shot phenomenon -- the count cannot be reset. If you need a version that resets the count, consider using a CyclicBarrier.

A CountDownLatch is a versatile synchronization tool and can be used for a number of purposes. A CountDownLatch initialized with a count of one serves as a simple on/off latch, or gate: all threads invoking await wait at the gate until it is opened by a thread invoking countDown(). A CountDownLatch initialized to N can be used to make one thread wait until N threads have completed some action, or some action has been completed N times.

A useful property of a CountDownLatch is that it doesn't require that threads calling countDown wait for the count to reach zero before proceeding, it simply prevents any thread from proceeding past an await until all threads could pass.

用来同步一个或多个任务，强制它们等待其他任务执行的一组操作完成。可以这么理解，有两组任务A，B。A的多个任务等待B组的所有任务结束才能执行。

CountDownLatch对象设置一个初始的值。A中的任务执行前先调用CountDownLatch.await()方法将当前任务阻塞，当CountDownLatch的值为0时才能进行下去。B中的每个任务执行完都调用CountDownLatch.countDown()来减小计数值。这样就可以保证B中的任务可以同时进行，当B的任务全部结束，A的任务才可以开始。

CountDownLatch对象的计数值不能被再次重置，只能使用一次。想要重置，使用CyclicBarrier。

public class CountDownLatchDemo {
    static final int SIZE = 10;
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool();
        CountDownLatch latch = new CountDownLatch(SIZE);
        
        for(int i=0;i<10;i++){
            exec.execute(new A(latch));
        }
        
        for(int i=0;i<10;i++){
            exec.execute(new B(latch));
        }
        
        System.out.println("Launched all tasks");
        exec.shutdown();
    }
    
}

class B implements Runnable{
    private static int counter =0;
    private final int id = counter++;
    private static Random random = new Random(47);
    private final CountDownLatch latch;
    public B(CountDownLatch latch){
        this.latch=latch;    
    }
    
    public void run(){
        try{
            doWork();
            latch.countDown();//B中完成一次任务，计数值减1
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }

    private void doWork() throws InterruptedException {
        TimeUnit.MILLISECONDS.sleep(random.nextInt(10));
        System.out.println(this+" completed");
    }
    public String toString(){
        return String.format("B %1$-3d", id);
    }
}

class A implements Runnable{
    private static int counter =0;
    private final int id = counter++;
    private static Random random = new Random(57);
    private final CountDownLatch latch;
    public A(CountDownLatch latch){
        this.latch=latch;
    }
    @Override