1.CountDownLatch
CountDownLatch.wait()会使当前线程阻塞，直到CountDownLatch中的计数器递减完毕后继续执行。

public class CountDownLatchDemo {

private final static Logger log = Logger.getLogger(AtomicIntegerCyclicBarrierDemo.class);

public static void main(String[] args) {
        final CountDownLatch latch = new CountDownLatch(2);
        new Thread(){
                public void run() {
                                log.info(Thread.currentThread().getName() + " running");
                                latch.countDown();
                };
        }.start();
        new Thread(){
                public void run() {
                        try {
                                log.info(Thread.currentThread().getName() + " running");
                                Thread.sleep(5000);
                                latch.countDown();
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                };
        }.start();
        try {
                latch.await();
                log.info("all finished");
        } catch (InterruptedException e) {
                e.printStackTrace();
        }
    }
}

运行日志：
2019-10-24 09:23:24,069-[HL][17] INFO Thread-0 AtomicIntegerCyclicBarrierDemo – Thread-0 running
2019-10-24 09:23:24,075-[HL][24] INFO Thread-1 AtomicIntegerCyclicBarrierDemo – Thread-1 running
2019-10-24 09:23:29,076-[HL][34] INFO main AtomicIntegerCyclicBarrierDemo – all finished
见第三条09:23:29，主线程一直阻塞直到线程2完成后才继续向下执行

2.CyclicBarrier
CyclicBarrier可以比做一个阻拦器，当同时阻塞的线程数达到某个个数时，才会将所有线程放行，这里结合 同样是并发包中的AtomicInteger实现了一个案例，AtomicInteger时基于CAS实现的乐观锁，也就是说当修改值与预期值不一致时，AtomicInteger会修改失败并重试，也就是说当我们用多个线程同时累加，在所有线程执行完毕之后，结果是安全的

public class AtomicIntegerCyclicBarrierDemo {

private final static Logger log = Logger.getLogger(AtomicIntegerCyclicBarrierDemo.class);

private final static AtomicInteger count = new AtomicInteger(0);

private final static int THREAD_COUNT = 100;

    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT, new Runnable() {
            public void run() {
                log.info(String.format("result = %s", count.get()));
            }
        });
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Task(barrier, count).start();
        }
    }
}

class Task extends Thread {

private CyclicBarrier cyclicBarrier;

private AtomicInteger count;

public Task(CyclicBarrier cyclicBarrier, AtomicInteger count) {
    this.cyclicBarrier = cyclicBarrier;
    this.count = count;
}

@Override
public void run() {
    super.run();
    try {
        count.addAndGet(2);
        cyclicBarrier.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (BrokenBarrierException e) {
        e.printStackTrace();
    }
}
}

运行日志：
2019-10-24 09:40:11,961-[HL][22] INFO Thread-99 AtomicIntegerCyclicBarrierDemo – result = 200
CyclicBarrier帮助我们在所有线程执行完之后，进行结果的打印

3.Semaphore
Semaphore用来控制可同时运行的线程数，比如一个案例，我们有一些模型转换任务，为了控制计算资源占用，只允许同时3个线程同时运行，每当一个线程运行完才能空出一个槽位给新的线程运行，下面见代码

public class SemaphoreDemo {

private final static int THREAD_COUNT = 8 ;

public static void main(String[] args) {
    Semaphore semaphore = new Semaphore(3);
    for(int i = 0; i < THREAD_COUNT ; i++) {
        try {
            Thread.sleep(2000);
            new Task2(i, semaphore).start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
}

class Task2 extends Thread{

private final static Logger log = Logger.getLogger(Task2.class);

private int num;

private Semaphore semaphore;

public Task2(int num,Semaphore semaphore){
    this.num = num;
    this.semaphore = semaphore;
}

@Override
public void run() {
    try {
        semaphore.acquire();
        log.info(String.format("task(id = %s) opeater", this.num));
        Thread.sleep(10000);
        log.info(String.format("task(id = %s) finished", this.num));
        semaphore.release();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
}

运行日志：
2019-10-24 09:51:49,180-[HL][39] INFO Thread-0 Task2 – task(id = 0) opeater
2019-10-24 09:51:51,150-[HL][39] INFO Thread-1 Task2 – task(id = 1) opeater
2019-10-24 09:51:53,151-[HL][39] INFO Thread-2 Task2 – task(id = 2) opeater
2019-10-24 09:51:59,190-[HL][41] INFO Thread-0 Task2 – task(id = 0) finished
2019-10-24 09:51:59,190-[HL][39] INFO Thread-3 Task2 – task(id = 3) opeater
2019-10-24 09:52:01,151-[HL][41] INFO Thread-1 Task2 – task(id = 1) finished
2019-10-24 09:52:01,152-[HL][39] INFO Thread-4 Task2 – task(id = 4) opeater
2019-10-24 09:52:03,151-[HL][41] INFO Thread-2 Task2 – task(id = 2) finished
2019-10-24 09:52:03,159-[HL][39] INFO Thread-5 Task2 – task(id = 5) opeater