第一.CountDownLatch

让一些线程阻塞知道另外一个线程完成一系列操作后才被唤醒
CountDownLatch主要有2个方法，当一个或多个线程调用await方法时，调用线程会被阻塞。当其他线程调用countDown方法会将计数器减一(调用countDown方法的线程不会阻塞),

当计数器的值变为0时，因调用await方法被阻塞的线程会被唤醒，继续执行。

public class CountDownLatchDemo {
    public static void main(String[] args) throws Exception{
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 1; i <=10; i++) {
            int finalI = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+":"+ finalI);
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println("子线程结束，主线程main开始");
    }
}

第二、Semaphore

(计数信号量)Semaphore
信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。

比如某商场就 5 个停车位，每个停车位只能停一辆车，如果这个时候来了 10 辆车，必须要等前面有空的车位才能进入。

public class SemaphoreDemo {
    public static void main(String[] args) throws Exception{
        //模拟5停车位
        Semaphore semaphore = new Semaphore(5);//同步关键类，构造方法传入的数字是多少，则同一个时刻，只运行多少个进程同时运行制定代码
        //模拟10个车子
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try {
                    /**
                     * 在 semaphore.acquire() 和 semaphore.release()之间的代码，同一时刻只允许制定个数的线程进入，
                     * 因为semaphore的构造方法是1，则同一时刻只允许一个线程进入，其他线程只能等待。
                     *
                     * */
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"\t 抢到车位");
                    Thread.sleep(3000);
                    System.out.println(Thread.currentThread().getName()+"\t停车3s后离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

原文地址：https://www.cnblogs.com/cxyyh/p/11569007.html