CountDownLatch

		CountDownLatch countDownLatch = new CountDownLatch(10);
        for(int i = 0;i<10;i++){
            Thread thread = new Thread(() -> {

                System.out.println(Thread.currentThread().getName()+"在路上");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"到达");
                countDownLatch.countDown();
            },"男"+i);
            thread.start();
        }
        countDownLatch.await();
        System.out.println("集合完毕");

public class CountDownLatch {
	//同步器
	private final Sync sync;
	//构造方法，count计数
	public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }
}

Sync

	private static final class Sync extends AbstractQueuedSynchronizer {
		//构造方法，将count赋值给state，相当于初始化锁数量
        Sync(int count) {
            setState(count);
        }
		//获取剩余state数量
        int getCount() {
            return getState();
        }
		//上锁
        protected int tryAcquireShared(int acquires) {
        	//判断剩余state是否为0，如果小于零，执行doAcquireSharedInterruptibly(arg)方法，放行
            return (getState() == 0) ? 1 : -1;
        }
		//释放锁
        protected boolean tryReleaseShared(int releases) {
            for (;;) {
                int c = getState(); //获取当前剩余锁数量
                if (c == 0) //锁数量为0 
                    return false;
                int nextc = c-1; //锁数量-1
                if (compareAndSetState(c, nextc)) //替换锁数量
                    return nextc == 0; //如果锁数量为0，所有的线程都已完成任务，然后在闭锁上等待的线程就可以恢复执行任务
            }
        }
    }

countDown()
countDown方法每次使state减1

	public void countDown() {
        sync.releaseShared(1);
    }

await()
调用await方法的线程会被阻塞，直到state的值为0时线程才会继续执行

	public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

CountDownLatch可以使一个线程等待其他线程执行完毕后才执行，初始化的时候将传入的count赋值给state，同过countDown()方法每次使state减1，通过await()方法阻塞线程，直至state为0使才放行。countDown()相当于释放锁的过程。