// 构造一个用给定计数初始化的CountDownLatch
CountDownLatch(int count)

// 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断
void await()
// 使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间
boolean await(long timeout, TimeUnit unit)
// 递减锁存器的计数，如果计数到达零，则释放所有等待的线程
void countDown()
// 返回当前计数
long getCount()
// 返回标识此锁存器及其状态的字符串
String toString()

package com.coderap.juc.lock.tools;

import java.util.*;
import java.util.concurrent.CountDownLatch;

class Runner implements Runnable {

    private CountDownLatch prepareLatch;
    private CountDownLatch startLatch;
    private CountDownLatch endLatch;
    private TreeMap<String, Long> results;

    public Runner(CountDownLatch prepareLatch, CountDownLatch startLatch, CountDownLatch endLatch, TreeMap<String, Long> results) {
        this.prepareLatch = prepareLatch;
        this.startLatch = startLatch;
        this.endLatch = endLatch;
        this.results = results;
    }

    @Override
    public void run() {
        // 开始准备
        System.out.println(new Date().getTime() + ": " + Thread.currentThread().getName() + " begin prepare");
        try {
            // 模拟准备工作花费的时间
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 准备工作完成，将prepareLatch进行countDown，告诉裁判
        this.prepareLatch.countDown();
        System.out.println(new Date().getTime() + ": " + Thread.currentThread().getName() + " prepared already, wait the action signal");
        try {
            // 等待裁判发命令起跑
            this.startLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 开始起跑
        System.out.println(new Date().getTime() + ": " + Thread.currentThread().getName() + " begin run");
        long startTime = System.currentTimeMillis();
        try {
            // 模拟跑步花费时间
            Thread.sleep(new Random().nextInt(3000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        // 计算花费时间，并存入results
        System.out.println(new Date().getTime() + ": " + Thread.currentThread().getName() + " end run, use time: " + (endTime - startTime) + " ms");
        this.results.put(Thread.currentThread().getName(), endTime - startTime);

        // 跑完全程，将endLatch进行countDown，告诉裁判
        this.endLatch.countDown();
    }
}

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {

        // 参赛人数
        int runnerCount = 10;

        // 用于准备就绪的栅栏
        CountDownLatch prepareLatch = new CountDownLatch(runnerCount);
        // 用于起跑的栅栏
        CountDownLatch startLatch = new CountDownLatch(1);
        // 用于结束后计算排名的栅栏
        CountDownLatch endLatch = new CountDownLatch(runnerCount);

        // 用于装载最后结果的Map
        TreeMap<String, Long> results = new TreeMap<>();

        for (int i = 0; i < runnerCount; i++) {
            // for循环创建相应数量的线程
            new Thread(new Runner(prepareLatch, startLatch, endLatch, results), "Runner " + i).start();
        }

        // 等待所有线程准备完毕
        prepareLatch.await();
        System.out.println("-------------------- All Runners Already --------------------");

        // 发号起跑
        startLatch.countDown();
        System.out.println("-------------------- Begin Run, Wait Results --------------------");

        // 等待所有线程结束
        endLatch.await();

        // 所有线程结束后，就可以计算排名了
        System.out.println("-------------------- Results Rank --------------------");
        System.out.println("All Participate Runners Count: " + results.size());
        List<Map.Entry<String, Long>> resultsList = new ArrayList<>(results.entrySet());
        Collections.sort(resultsList, new Comparator<Map.Entry<String, Long>>() {
            public int compare(Map.Entry<String, Long> o1, Map.Entry<String, Long> o2) {
                return (int) (o1.getValue() - o2.getValue());
            }
        });

        for (Map.Entry<String, Long> result : resultsList) {
            System.out.println(result.getValue() + " : " + result.getKey());
        }

    }
}

1540780225299: Runner 0 begin prepare
1540780225299: Runner 5 begin prepare
1540780225300: Runner 4 begin prepare
1540780225300: Runner 3 begin prepare
1540780225300: Runner 2 begin prepare
1540780225300: Runner 7 begin prepare
1540780225300: Runner 1 begin prepare
1540780225300: Runner 6 begin prepare
1540780225300: Runner 8 begin prepare
1540780225300: Runner 9 begin prepare
1540780225333: Runner 4 prepared already, wait the action signal
1540780225358: Runner 7 prepared already, wait the action signal
1540780225505: Runner 5 prepared already, wait the action signal
1540780225602: Runner 6 prepared already, wait the action signal
1540780225664: Runner 3 prepared already, wait the action signal
1540780225692: Runner 8 prepared already, wait the action signal
1540780225753: Runner 1 prepared already, wait the action signal
1540780225867: Runner 2 prepared already, wait the action signal
1540780225932: Runner 0 prepared already, wait the action signal
1540780226109: Runner 9 prepared already, wait the action signal
-------------------- All Runners Already --------------------
-------------------- Begin Run, Wait Results --------------------
1540780226109: Runner 4 begin run
1540780226109: Runner 7 begin run
1540780226109: Runner 5 begin run
1540780226110: Runner 6 begin run
1540780226110: Runner 3 begin run
1540780226110: Runner 8 begin run
1540780226110: Runner 1 begin run
1540780226110: Runner 2 begin run
1540780226110: Runner 9 begin run
1540780226110: Runner 0 begin run
1540780226217: Runner 7 end run, use time: 107 ms
1540780226338: Runner 5 end run, use time: 228 ms
1540780226638: Runner 6 end run, use time: 528 ms
1540780226780: Runner 2 end run, use time: 670 ms
1540780227023: Runner 0 end run, use time: 913 ms
1540780227182: Runner 1 end run, use time: 1072 ms
1540780227834: Runner 8 end run, use time: 1724 ms
1540780227847: Runner 4 end run, use time: 1738 ms
1540780227902: Runner 3 end run, use time: 1792 ms
1540780228582: Runner 9 end run, use time: 2472 ms
-------------------- Results Rank --------------------
All Participate Runners Count: 10
107 : Runner 7
228 : Runner 5
528 : Runner 6
670 : Runner 2
913 : Runner 0
1072 : Runner 1
1724 : Runner 8
1738 : Runner 4
1792 : Runner 3
2472 : Runner 9

package java.util.concurrent;
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) {
            // 直接将state设置为count
            setState(count);
        }

        // 获取count，其实就是state的值
        int getCount() {
            return getState();
        }

        protected int tryAcquireShared(int acquires) {
            // 当state为0时表示获取共享锁成功，否则失败
            return (getState() == 0) ? 1 : -1;
        }

        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            // 自旋更新state，当state为0时表示可以唤醒阻塞的线程了
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c - 1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

    // 同步器
    private final Sync sync;

    // 构造方法，会使用传入的count参数直接创建一个Sync对象
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        // 创建Sync对象
        this.sync = new Sync(count);
    }

    public void await() throws InterruptedException {
        // Sync的acquireSharedInterruptibly()方法来自于父类AQS
        sync.acquireSharedInterruptibly(1);
    }

    public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
        // Sync的tryAcquireSharedNanos()方法来自于父类AQS
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    public void countDown() {
        // Sync的releaseShared()方法来自于父类AQS
        sync.releaseShared(1);
    }

    public long getCount() {
        return sync.getCount();
    }

    public String toString() {
        return super.toString() + "[Count = " + sync.getCount() + "]";
    }
}

public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

protected boolean tryReleaseShared(int releases) {
    // Decrement count; signal when transition to zero
    // 自旋更新state，当state为0时表示可以唤醒阻塞的线程了
    for (;;) {
        int c = getState();
        if (c == 0)
            return false;
        int nextc = c - 1;
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}