CountDownLatch

CountDownLatch 针对有强先后关系类的并发顺序，而不是允许随机的情况。

CountDownLatch其实可以把它看作一个计数器，只不过这个计数器的操作是原子操作，同时只能有一个线程去操作这个计数器，也就是同时只能有一个线程去减这个计数器里面的值。
你可以向CountDownLatch对象设置一个初始的数字作为计数值，任何调用这个对象上的await()方法都会阻塞，直到这个计数器的计数值被其他的线程减为0为止。
CountDownLatch的一个非常典型的应用场景是：有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法，其他的任务执行完自己的任务后调用同一个CountDownLatch对象上的countDown()方法，这个调用await()方法的任务将一直阻塞等待，直到这个CountDownLatch对象的计数值减到0为止。

运动员示例：

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * Created by bingone on 15/12/28.
 */
public class Test {
    public static CountDownLatch playGround = new CountDownLatch(1);
    public static Random random = new Random();
    public static ExecutorService executorService = Executors.newCachedThreadPool();
    public static CountDownLatch begin;
    public static CountDownLatch end;
    public static int num = 5;
    public static void main(String... args) throws IOException {
        executorService.submit(new judge("Tom", num));
        for(int i = 0;i<num;i++){
            final String name = "num"+i;
            executorService.submit(new Runnable() {
                String name;
                {
                    name="asfd";
                }
                public Runnable test(){
                    System.out.println("construct");
                    return this;
                }
                @Override public void run() {
                    System.out.println("player " + name + " await ...");
                    try {
                        begin.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("player " + name + " running~~~");
                    try {
                        Thread.sleep(random.nextInt(10)*1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("player " + name + " arrive final");
                    end.countDown();
                }
            }.test());
        }

        System.out.println("playground haven't ready");
        playGround.countDown();
        executorService.shutdown();
        while(!executorService.isTerminated())
            Thread.yield();
        System.out.println("all is over");

    }

    public static final class judge implements Runnable {

        String name;
        public judge(String name, int player) {
            this.name = name;
            begin = new CountDownLatch(1);
            end = new CountDownLatch(player);
        }

        @Override public void run() {
            System.out.println("judge " + name + " come in playground");
            try {
                System.out.println("judge " + name + " await playground");
                playGround.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("judge blow a whistle");
            begin.countDown();
            try {
                System.out.println("judge " + name + " await players");
                end.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("judge " + name + "says end");
        }
    }
}