一：CountDownLatch

​import java.util.concurrent.CountDownLatch;
class CountDownLatchDemo {/*** CountDownLatch：闭锁* 在完成一组正在其他线程中执行的操作之前，它约束一个或多个线程一直等待。* 可用于：子任务执行完成后再进行另一个操作。*/static void test(int threadTaskNum) {final CountDownLatch answers = new CountDownLatch(threadTaskNum);//同步计数器for (int i = 0; i < threadTaskNum; i++) {new Thread(new Runnable() {@Overridepublic void run() {try {System.out.println("线程" + Thread.currentThread().getName() + " 开始处理任务 ...");Thread.sleep((long) (Math.random() * 5000));System.out.println("线程" + Thread.currentThread().getName() + " 处理完毕，汇报结果！");answers.countDown();} catch (Exception e) {}}}).start();}try {answers.await();// 在所有子线程结束前保持阻塞} catch (InterruptedException e) {}System.out.println("线程" + Thread.currentThread().getName() + "已收到所有汇报结果");}
}
public class Test {public static void main(String[] args) {CountDownLatchDemo.test(3);}
}​

输出结果：

线程Thread-0 开始处理任务 ...线程Thread-1 开始处理任务 ...线程Thread-2 开始处理任务 ...线程Thread-0 处理完毕，汇报结果！线程Thread-1 处理完毕，汇报结果！线程Thread-2 处理完毕，汇报结果！线程main已收到所有汇报结果

当所有子线程执行完毕以后，主线程再进行下一步。   （理解为“减法”）

二：CyclicBarrier

import java.util.concurrent.CyclicBarrier;
class CyclicBarrierDemo {/*** CyclicBarrier：关卡* 它约束多线程必需同时达到某时刻，同时向下执行，在没有达到之前保持等待* 比如：周末约定去爬山，在公司门口集合，必须要等所有人都到后大家在一起出发。*/static void test(int threadNum) {//        CyclicBarrier cyclicBarrier  = new CyclicBarrier(3);// 构造方法可支持一个Runnable，用于在所有线程都达到后首先执行。final CyclicBarrier cyclicBarrier  = new CyclicBarrier(3, new Runnable() {@Overridepublic void run() {System.out.println("都准备好了！");}});for (int i = 0; i < threadNum; i++) {new Thread(new Runnable() {@Overridepublic void run() {try {System.out.println("线程" + Thread.currentThread().getName() + " 已经准备好.");cyclicBarrier.await();Thread.sleep((long) (Math.random() * 2000));System.out.println("线程" + Thread.currentThread().getName() + " 处理完毕，汇报结果！");} catch (Exception e) {}}}).start();}}
}
public class Test {public static void main(String[] args) {CyclicBarrierDemo.test(3);}
}

输出结果：

线程Thread-0 已经准备好.线程Thread-1 已经准备好.线程Thread-2 已经准备好.都准备好了！线程Thread-1 处理完毕，汇报结果！线程Thread-0 处理完毕，汇报结果！线程Thread-2 处理完毕，汇报结果！

三个线程相互等待直到都准备好了以后同时开始向下执行。   （理解为“加法”）

三：Semaphore

import java.util.concurrent.Semaphore;
class SemaphoreDemo {/*** Semaphore：信号量* 当前在多线程环境下被扩放使用，操作系统的信号量是个很重要的概念，在进程控制方面都有应用。* Java 并发库 的Semaphore 可以很轻松完成信号量控制，* Semaphore可以控制某个资源可被同时访问的个数，* 通过 acquire() 获取一个许可，如果没有就等待，* 通过 release() 释放一个许可。* 比如在Windows下可以设置共享文件的最大客户端访问个数。*/static void test(int threadNum) {
//        Semaphore semaphore = new Semaphore(threadNum, true);// 是否公平final Semaphore semaphore = new Semaphore(3);//最多同时允许 3 个线程并发访问for (int i = 0; i < threadNum; i++) {new Thread(new Runnable() {@Overridepublic void run() {try {System.out.println("线程" + Thread.currentThread().getName() + " 想要处理，剩余凭证：" + semaphore.availablePermits());semaphore.acquire();Thread.sleep((long) (Math.random() * 2000));System.out.println("线程" + Thread.currentThread().getName() + " 处理完毕，归还凭证！");// 如果注释下面这行，表示不释放凭证，那么后续线程将永远阻塞在semaphore.acquire();上semaphore.release();// 用完后要释放，以给其它线程使用} catch (Exception e) {}}}).start();}}
}
public class Test {public static void main(String[] args) {SemaphoreDemo.test(5);}
}

输出结果：

线程Thread-0 想要处理，剩余凭证：3线程Thread-1 想要处理，剩余凭证：2线程Thread-2 想要处理，剩余凭证：1线程Thread-3 想要处理，剩余凭证：0线程Thread-4 想要处理，剩余凭证：0线程Thread-0 处理完毕，归还凭证！线程Thread-1 处理完毕，归还凭证！线程Thread-3 处理完毕，归还凭证！线程Thread-2 处理完毕，归还凭证！线程Thread-4 处理完毕，归还凭证！

因为凭证只有三张，3和4两个线程在一开始拿不到凭证（剩余凭证为0）会阻塞直到有线程归还后才能拿到，从而控制了并发访问的线程数量。    （理解为“抢车位”）