1、JUC是什么？
JUC是java并发包java.util.concurrent的缩写，就是这么简单明了～～～
在我们JDK的并发包中，提供了几个非常有用的并发工具类，比如：CountDownLatch 闭锁、CyclicBarrier 同步屏障、Semaphore 信号量，在线程之间交换数据的一种方式 Exchanger，赶紧操练起来。
2、CountDownLatch 闭锁
这个CountDownLatch可以说是Join()方法的升级版，join用于让当前执行的线程，等待调用join的线程执行结束，然后在接着往下执行。
-
/**
-
* @Auther: IT贱男
-
* @Date: 2020/5/8 14:16
-
* @Description: join
-
*/
-
public
class JoinTest {
-
-
static
class JoinThread extends Thread {
-
@Override
-
public void run() {
-
System.out.println(
"JoinThread thread running");
-
try {
-
Thread.sleep(
2000L);
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
System.out.println(
"JoinThread thread over");
-
}
-
}
-
-
public static void main(String[] args) {
-
System.out.println(
"main is running");
-
JoinThread joinThread =
new JoinThread();
-
joinThread.start();
-
-
try {
-
// 让主线线程等待joinThread执行完成，才继续往下执行
-
joinThread.join();
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
System.out.println(
"main is over");
-
-
}
-
}
执行结果如下：
main is running
JoinThread thread running
JoinThread thread over
main is over
从代码可以，在main方法中调用了JoinThread的join方法，mian这个主线程，就必须等到JoinThread这个线程执行完毕才会接着执行。 join的原理其实就是不停的去检查join的线程是否还存活，如果join线程存活则让当前线程永远等待。一直到join线程执行完了，线程的this.notifyAll()就会被调用，调用notifyAll()方法是在JVM里面进行实现的。
join部分源码如下，其中wait(0)就是表示永远等待下去，isAlive()检查是否存活。
-
while (isAlive()) {
-
wait(
0);
-
}
在回过头来看CountDownLatch，在JDK1.5之后的并发包中提供的CountDownLatch也可以实现join的功能，它允许一个或者多个线程等待其他线程完成操作。
我们先来看看它的构造函数：
-
public CountDownLatch(int count) {
-
if (count <
0)
throw
new IllegalArgumentException(
"count < 0");
-
this.sync =
new Sync(count);
-
}
CountDownLatch的构造函数接受一个int类型的参数作为计数器。假设现在启动一个任务，需要开启5个线程去完成初始化工作，一直到初始化的工作全部做完了，业务线程和主线才接着执行后续代码，所以这里构造函数中我们就需要传5进去。
常用的方法如如下：
-
public void await() throws InterruptedException {
-
sync.acquireSharedInterruptibly(
1);
-
}
-
public void countDown() {
-
sync.releaseShared(
1);
-
}
当我们调用CountDownLatch的await()方法时，该线程会被阻塞，一直到计数器变成0才被唤醒。
countDown()方法调用一次，计数器就会减1，一直到计数器被减到0时，调用await()的线程才可以继续执行。
注意：计数器必须大于等于0，只是如果等于0的时候，计数器就是0，线程调用await()方法也不会进入阻塞状态。
代码演示：现在启动一个任务，需要等待5个线程全部初始化完毕之后，主线程和业务线程才可以执行执行。
-
/**
-
* @Auther: IT贱男
-
* @Date: 2020/4/29 16:44
-
* @Description: Show CountDownLatch test
-
*/
-
public
class CountDownLatchTest {
-
-
// 一个线程也可以进行减多次
-
static CountDownLatch latch =
new CountDownLatch(
5);
-
-
/**
-
* 初始化线程
-
*/
-
static
class InitTask implements Runnable {
-
@Override
-
public void run() {
-
try {
-
Thread.sleep(
1000L);
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
System.out.println(Thread.currentThread().getId() +
"InitTask thread init ");
-
// 计数器 -1
-
latch.countDown();
-
}
-
}
-
-
-
/**
-
* 业务线程
-
*/
-
static
class BusinessTask implements Runnable {
-
@Override
-
public void run() {
-
try {
-
// 等待初始化线程完成
-
latch.await();
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
System.out.println(
"Business thread start work");
-
}
-
}
-
-
-
public static void main(String[] args) {
-
-
// 初始化5个线程
-
for (
int i =
0; i <
5; i++) {
-
Thread thread =
new Thread(
new InitTask());
-
thread.start();
-
}
-
-
// 启动业务线程，必须要等到初始化线程5个全部完成，才开始执行业务代码
-
new Thread(
new BusinessTask()).start();
-
-
-
try {
-
// 主线程也要等待初始化线程完成，才接着往下走
-
latch.await();
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
-
// 必须要等到初始化线程5个全部完成，才会走到这里
-
System.out.println(
"Main thread is start work");
-
}
-
}
执行结果如下：
13InitTask thread init
10InitTask thread init
14InitTask thread init
11InitTask thread init
12InitTask thread init
Main thread is start work
Business thread start work
CountDownLatch还有一个await带参数的方法，如果初始化线程执行特别慢，或者因为异常了没有正常调用countDown()方法，我们也不可能让其他线程一直等着，所以可以使用另外一个带指定时间的await方法，该方法等待特定的时间以后，就不会再阻塞当前线程。
-
public boolean await(long timeout, TimeUnit unit)
-
throws InterruptedException {
-
return sync.tryAcquireSharedNanos(
1, unit.toNanos(timeout));
-
}
3、CyclicBarrier 同步屏障
它要做的事情就是让一组线程达到一个同步点(也可以说屏障)，等到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截点线程才会继续运行，并且可以循环使用。
举个例子，森林冰火双人游戏不知道小伙伴有没有玩过，必须要两个玩家全部到达门时，门(屏障)才会开。
CyclicBarrier提供了两种构造函数：
第一种构造函数：
-
public CyclicBarrier(int parties) {
-
this(parties,
null);
-
}
默认的构造函数就是CyclicBarrier(int parites)，其参数表示屏障拦截的线程数量，每个线程调用await()方法告诉CyclicBarrier 我已经到达了屏障，当然当前线程被阻塞。 一直到指定数量的线程被拦截，才能放行。
调用await()，相当于计数器加1，一直达到等于parties数量，则屏障打开。
-
-
/**
-
* @Auther: IT贱男
-
* @Date: 2020/4/29 17:17
-
* @Description: Show CyclicBarrier test
-
*/
-
public
class CyclicBarrierTest {
-
-
// 由线程本身控制是否完成
-
static CyclicBarrier barrier =
new CyclicBarrier(
2);
-
-
// 初始化线程
-
static
class InitTask extends Thread {
-
@Override
-
public void run() {
-
try {
-
// 随机睡眠
-
Thread.sleep(
new Random().nextInt(
2000));
-
System.out.println(Thread.currentThread().getName() +
"到达终点");
-
barrier.await();
-
}
catch (Exception e) {
-
e.printStackTrace();
-
}
-
// 必须冰妹妹，和火哥哥两个玩家全部执行完await()方法，才算成功
-
System.out.println(
"恭喜" + Thread.currentThread().getName() +
"闯关成功");
-
}
-
}
-
-
-
public static void main(String[] args) {
-
-
InitTask initMM =
new InitTask();
-
initMM.setName(
"冰妹妹");
-
-
InitTask initGG =
new InitTask();
-
initGG.setName(
"火哥哥");
-
-
initGG.start();
-
initMM.start();
-
}
-
}
执行结果如下：
冰妹妹到达终点
火哥哥到达终点
恭喜火哥哥闯关成功
恭喜冰妹妹闯关成功
由结果可见，必须要冰妹妹、火哥哥全部达到终点，双方才能被放行。
被放行的线程可能是冰妹妹优先执行、也有可能是火哥哥优先执行，都是由CPU决定的。
如果把new CyclicBarrier(2) 修改为 new CyclicBarrier(3) ，则先到达屏障的线程会一直处于等待状态，因为没有第三个线程调用await()方法，所以之前达到屏障的线程都不会继续执行。
第二种构造函数：
-
public CyclicBarrier(int parties, Runnable barrierAction) {
-
if (parties <=
0)
throw
new IllegalArgumentException();
-
this.parties = parties;
-
this.count = parties;
-
this.barrierCommand = barrierAction;
-
}
CyclicBarrier()还提供了更高级的构造函数，在全部线程都到达屏障的时候，优先执行barrierAction，方便处理更复杂的业务场景。 假设冰妹妹、火哥哥闯关成功了，需要优先加载下一个关卡资源，来提高用户体验。
-
/**
-
* @Auther: IT贱男
-
* @Date: 2020/4/29 17:17
-
* @Description: Show CyclicBarrier test
-
*/
-
public
class CyclicBarrierTest {
-
-
// 控制一组线程同时完全的情况下，代码接着执行，有线程本身控制是否完成
-
static CyclicBarrier barrier =
new CyclicBarrier(
2,
new BusinessTask());
-
-
// 业务线程
-
static
class BusinessTask implements Runnable {
-
@Override
-
public void run() {
-
System.out.println(
"开始加载下一关资源");
-
}
-
}
-
-
// 代码省略
-
}
执行结果如下：
火哥哥到达终点
冰妹妹到达终点
开始加载下一关资源
恭喜冰妹妹闯关成功
恭喜火哥哥闯关成功
循环使用：
这个森林冰火小游戏课时有很多关卡的，每一个关卡都是需要两个玩家同时到达屏障才算闯关成功。这里CyclicBarrier也是可以重复使用的，假设闯完第一关之后，继续闯第二关。
同步屏障计数器初始化还是2，但是我们开启了4个线程来执行，结果依然是正确，所以能够体现CyclicBarrier是可以循环使用的。
-
// 控制一组线程同时完全的情况下，代码接着执行，有线程本身控制是否完成
-
static CyclicBarrier barrier =
new CyclicBarrier(
2,
new BusinessTask());
-
-
// 其他代码保持一致
-
-
-
public static void main(String[] args) throws InterruptedException {
-
-
System.out.println(
"开始闯关：关卡一");
-
InitTask initMM =
new InitTask();
-
initMM.setName(
"冰妹妹");
-
-
InitTask initGG =
new InitTask();
-
initGG.setName(
"火哥哥");
-
-
initGG.start();
-
initMM.start();
-
-
// 关卡一完成之后，火哥哥内急去了一趟洗手间，睡眠5秒
-
Thread.sleep(
5000L);
-
System.out.println(
"开始闯关：关卡二");
-
InitTask initMM2 =
new InitTask();
-
initMM2.setName(
"冰妹妹");
-
-
InitTask initGG2 =
new InitTask();
-
initGG2.setName(
"火哥哥");
-
-
initMM2.start();
-
initGG2.start();
-
-
}
执行结果如下：
开始闯关：关卡一
冰妹妹到达终点
火哥哥到达终点
开始加载下一关资源
恭喜火哥哥闯关成功
恭喜冰妹妹闯关成功
开始闯关：关卡二
冰妹妹到达终点
火哥哥到达终点
开始加载下一关资源
恭喜火哥哥闯关成功
恭喜冰妹妹闯关成功
CountDownLatch 和 CyclicBarrier 区别
1、CountDownLatch 是依赖其他线程完成了某些操作来控制，而CliclicBarrier是有线程本身控制。 仔细想想CountDownLatch是等待其他五个初始化线程全部完成之后，主线程和业务现场才开始继续执行，是不是依赖其他线程控制。再想想冰妹妹和火哥哥，是必须要冰妹妹和火哥哥亲自完成到达屏障，屏障才会打开。
2、CountDownLatch每执行countDown()方法，计数器 - 1，而 CyclicBarrier 调用await()方法，计数器 + 1
3、CountDownLatch只可以使用一次，而CyclicBarrier可以重复使用。
4、CyclicBarrier还有一个很高级的构造函数，可以指定一个线程先进行操作。
4、Semaphore 信号量
用来控制同时访问特定资源的线程数量，它通过协调各个线程，来保证特定资源能够被合理使用。
Semaphore可以用于做流量控制，比如数据库连接，假设数据库同时连接的数量只能有5个，首先进来了5个线程拿到了许可证可以获得数据库连接，后进来的线程只能等待前面线程释放了，才可以拿到连接。
来看看Semaphore的构造函数：
-
public Semaphore(int permits) {
-
sync =
new NonfairSync(permits);
-
}
-
public Semaphore(int permits, boolean fair) {
-
sync = fair ?
new FairSync(permits) :
new NonfairSync(permits);
-
}
permits参数表示可用的许可证数量，比如Semaphore(5) 就表示运行5个线程能够同时获得资源。
fair 是控制是否公平锁，默认是非公平，传true则是公平锁。
大概解释下什么是公平和非公平，比如早餐排队买包子，大家都老老实实排队购买，这就是公平的。 这个时候来了个抠脚大汉，直接插入到队伍前面去买包子去了，这个时候就是不公平的体现了。
Semaphore 使用也很简单，通过Semaphore的acquire()方法拿到一个许可证，使用完成之后调用release()方法，来释放许可证。
-
/**
-
* @Auther: IT贱男
-
* @Date: 2020/4/30 14:50
-
* @Description: 信号量测试
-
*/
-
public
class SemaphoreTest {
-
-
private
static Semaphore semaphore =
new Semaphore(
5);
-
-
// 业务线程
-
static
class BusinessTask extends Thread {
-
@Override
-
public void run() {
-
try {
-
// 拿获取资格，拿不到就等着
-
semaphore.acquire();
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
try {
-
System.out.println(Thread.currentThread().getName() +
"拿到数据库连接");
-
// 随机睡眠
-
Thread.sleep(
new Random().nextInt(
2000));
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
// 释放资源
-
semaphore.release();
-
}
-
}
-
-
public static void main(String[] args) {
-
// 启动10个线程来获取资源
-
for (
int i =
0; i <
10; i++) {
-
BusinessTask task =
new BusinessTask();
-
task.start();
-
}
-
}
-
-
}
运行的结果，并不是10个线程一开始就能获取到资源，而是先前5个获取到，后五个等待资源被释放了，才进行获取。
Semaphore还提供了一些其他方法：
availablePermits() ：返回此Semaphore对象中当前可用的许可数。
getQueueLength()：返回正等待获取许可证的线程数。
hasQueuedThreads()： 是否有线程正在等待获取许可证。
等等.........
5、Exchanger 交换
用于线程之间协作的工具类，它提供了一个同步点，在这个同步点，两个线程可以交换彼此的数据。
这里注意只能是两个线程，当其中一个线程执行了exchange()方法，它会一直等待第二个线程也执行到exchange()方法的时候，两个线程就可以交换数据。
-
/**
-
* @Auther: IT贱男
-
* @Date: 2020/4/30 15:22
-
* @Description: 线程数据交换
-
*/
-
public
class ExchangeTest {
-
-
private
static Exchanger<String> exchanger =
new Exchanger<>();
-
-
static
class TaskA implements Runnable {
-
@Override
-
public void run() {
-
String str =
"我是线程A";
-
try {
-
System.out.println(
"TaskA --- 原始值 = " + str);
-
String exchange = exchanger.exchange(str);
-
System.out.println(
"TaskA --- 交换后的值 = " + exchange);
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
}
-
-
static
class TaskB implements Runnable {
-
@Override
-
public void run() {
-
String str =
"我是线程B";
-
try {
-
System.out.println(
"TaskB --- 原始值 = " + str);
-
String exchange = exchanger.exchange(str);
-
System.out.println(
"TaskB --- 交换后的值 = " + exchange);
-
}
catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
}
-
-
public static void main(String[] args) {
-
Thread thread =
new Thread(
new TaskA());
-
thread.start();
-
-
Thread thread1 =
new Thread(
new TaskB());
-
thread1.start();
-
}
-
}
执行结果如下：
TaskA --- 原始值 = 我是线程A
TaskB --- 原始值 = 我是线程B
TaskB --- 交换后的值 = 我是线程A
TaskA --- 交换后的值 = 我是线程B
可见，TaskA的值交换后，变成了 “我是线程B”，TaskB也是如此。
如果两个线程有一个没有执行到exchange()方法，则会一直等待，但是又不想等太长时间。可以使用
public V exchange(V x, long timeout, TimeUnit unit)方法，来设置最大的等待时长。
6、本章总结
本章介绍了JDK中提供的几个并发工具类，了解这四种工具类，如果遇到合适的业务场景可以不妨试试这些。
后续小编还会持续更新并发一系列相关技术点，比如并发容器、并发框架、锁、Java内存模型等等，从简单到深入，从长发飘飘到所剩无几。
看完不来个赞么？～～～～
转载：https://blog.csdn.net/weixin_38111957/article/details/105994854