概述
在JDK的并发包（java.util.concurrent）中，为我们提供了几个非常重要的并发工具类，分别为CountDownLatch、CyclicBarrier、Semaphore和Exchanger。
先上总结
1、CountDownLatch，它是一种计数器的方式保证线程同步；它不去控制多个子线程之间的前后关系，只保证某一线程能够在这些子线程执行完成后再执行。
2、CyclicBarrier，通过设置屏障的方式使得多线程同步，能够控制多个线程在屏障处等等其他线程也执行到屏障点，可以实现CountDownLatch具有的功能，但是比CountDownLatch功能强大；
3、Semaphore，信号量，用于控制访问某一公共资源的并发线程数；
4、Exchanger，用于两个线程之间的数据交换。
介绍
1）CountDownLatch
CountDownLatch，类似于计数器的方式，用于等待一个或多个线程执行完操作开始自身代码的执行。
其构造函数接收一个int类型的整数作为计数器而使用，例如如果想等待N个线程执行完毕就传入N，当每调用一次countDown函数，表示某一个线程执行完毕。实际上，这个N并不是与线程绑定，也就是说并不是一定和线程的数量一致，只需要countDown函数执行N次，当前等待的线程就会开始执行。下面列出具体代码：
public static class CountDownLatchTest {
static CountDownLatch countDownLatch = new CountDownLatch(2);
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
SleepUtils.second(2);
System.out.println("1");
countDownLatch.countDown();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
SleepUtils.second(4);
System.out.println("2");
countDownLatch.countDown();
}
}).start();
try {
// 主线程开始等待
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("3");
}
}输出如下：
1
2
3
Process finished with exit code 0注意点
1、如果传入的参数大于2，那么主线程将会一直等待。
2、计数器必须大于0，如果为0，调用await方法不会阻塞当前线程。
应用场景
当遇到一个比较耗时的计算量较大的任务时，我们则可以考虑使用多线程来操作，将一个大任务拆分成多个小任务（一个任务相当于一个线程），当每个小任务执行完毕返回结果后，再由某一主线程对结果进行统计。
2）CyclicBarrier
CyclicBarrier即同步屏障，它主要功能是让一组线程达到一个屏障（也可以称为同步点）是被阻塞，直到最后一个线程达到屏障是，屏障才被打开，所有被拦截的线程才会继续执行。
其构造函数默认也是接收一个int类型的参数N作为屏障拦截的线程数量，每个线程调用await方法表示到达了屏障点，然后被阻塞。具体示例如下：
public class CyclicBarrierTest {
// 参数表示屏障拦截的线程数量， 每个线程调用 await方法，告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞
// 屏障拦截的线程数量必须和当前的线程数一致，并且都调用await方法，否则当前所有的线程都处于等待状态
static CyclicBarrier c = new CyclicBarrier(3);
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println("1---1 " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
c.await();
} catch (BrokenBarrierException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("1---2 " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("2---1 " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
try {
c.await();
} catch (BrokenBarrierException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("2---2 " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}).start();
SleepUtils.second(2);
System.out.println("3---1 " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
try {
c.await();
} catch (BrokenBarrierException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("3---2 " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}输出如下：
1---1 17:05:01
2---1 17:05:01
3---1 17:05:03
3---2 17:05:03
1---2 17:05:03
2---2 17:05:03
Process finished with exit code 0注意点
1、构造函数中的N必须为线程的总数，当最后一个线程调用await方法（到达屏障）时，屏障才会打开，被阻塞的线程才会执行，这里的N表示的含义和CountDownLatch传入的N是不一样的。
2、我们发现，当所有线程都到达屏障时，当屏障打开，接下来会优先执行哪个线程呢？如上代码答案是不确定的。但是CyclicBarrier为我们提供了一个更高级的用法，即构造函数还支持传递一个Runnable对象，当屏障打开时，优先执行Runnable中的run方法。（这一功能十分强大，完全可以替代CountDownLatch了）
应用场景
同CountDownLatch
与CountDownLatch区别：
CountDownLatch计数器只能使用一次，而CyclicBarrier的计数器可以使用 reset方法重置，所以适合更复杂的业务场景。
3）Semaphore
Semaphore即信号量，主要用来控制并发访问特定资源的线程数量，协调各个线程合理使用公共资源。
构造函数同样也是接收一个int类型的参数N作为入参，用来限制访问某一公共资源最大的线程并发数，通过acquire来获取许可证，release释放许可证。
具体示例如下：
public class SemaphoreTest {
private static final int THREAD_COUNT = 6;
private static ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);
private static Semaphore semaphore = new Semaphore(2);
public static void main(String[] args) {
for (int i = 0; i < THREAD_COUNT; i++) {
threadPool.execute(new MyRunnable(i + 1));
}
threadPool.shutdown();
}
static class MyRunnable implements Runnable {
private int sleep;
public MyRunnable(int sleep) {
this.sleep = sleep;
}
@Override
public void run() {
try {
semaphore.acquire();
System.out.println("save data " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
SleepUtils.second(sleep);
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}输出如下：
save data 19:44:37
save data 19:44:37
save data 19:44:38
save data 19:44:39
save data 19:44:41
save data 19:44:43
Process finished with exit code 0注意点
1、通过输出可以发现，线程的并发数量为2，当有一个线程执行完后则下一个线程才获取到资源。
应用场景
我们有大量的线程在完成一个巨量任务的时候，但是某一公共资源却有限定了线程的链接树，这时候就需要对这些大量线程访问这一公共资源做控制。例如当我们有上百个线程需要处理本地上G的数据文件，每个线程处理完成之后需要把结果写到数据库，而数据库只支持十个线程的并发链接，此时，对数据库的链接我们就可以通过Semaphore来控制最大连接数。
4）Exchanger
Exchanger（交换者），它是用于线程间的协作工具类，主要用于线程间数据的交换。它提供了一个同步点，在这个同步点，两个线程可以交换彼此的数据。下面看具体demo：
public class ExchangerTest {
private static final Exchanger<String> exchanger = new Exchanger<>();
private static ExecutorService threadPool = Executors.newFixedThreadPool(2);
public static void main(String[] args) {
threadPool.execute(new Runnable() {
@Override
public void run() {
String a = "aaaaaaaaaa";
try {
String b = exchanger.exchange(a);
System.out.println("---" + b);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
threadPool.execute(new Runnable() {
@Override
public void run() {
try {
String b = "bbbbbbbb";
String a = exchanger.exchange("bababa");
System.out.println("a is " + a + " , b is " + b);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
threadPool.shutdown();
}
}输出如下：
---bababa
a is aaaaaaaaaa , b is bbbbbbbb
Process finished with exit code 0注意点
1、Exchanger只能作用于两个线程之间，如果作用于第三个线程，则第三个线程一直处于等待中；
2、exchange中还有一个重载函数，接收一个等待时长，用于避免一直等待。
参考文献
《Java并发编程的艺术》