JUC 是学习 Java 并发编程的小伙伴不可避免的一个 pkg，JUC提供了对并发编程的底层支持，比如我们熟悉的线程池、MQ、线程同步... 都有JUC的影子，下面我们一起来看看JUC下比较重要的几个class。
CountdownLatch
先看一下 **latch **是什么意思：
门闩大家都知道吧，假设我们现在有一扇铁门，每个线程跑到这铁门时都取下一把门闩，当所有的门闩都从门上取下来时，门就打开了，线程就可以继续往下执行。
public class CountdownLatchTest {
public static void main(String[] args) throws InterruptedException {
// 传入放多少个门闩
CountDownLatch cdl = new CountDownLatch(10);
// 启 10 个线程
for (int i = 0; i < 10; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " 取下一把门闩");
// 每个线程运行完就取下一把门闩
cdl.countDown();
}, "线程" + i).start();
}
// 铁门在这等着门闩被取完了才打开
cdl.await();
System.out.println("门打开了");
}
}
运行结果：
在实际开发中，我们常用多个门闩来对多个线程的执行顺序进行控制，后面有机会给大家分享一下案例。
CyclicBarrier
我们要搞清楚一个东西肯定得知道他是什么意思，大佬对命名都是很讲究的。（我大学刚接触编程都是 a,b,c,d,e,f,g命名）
单词每个都认识，连在一起就不知道是什么意思了。
循环的障碍？循环的屏障？其实都无所谓，自己挑一个容易理解的名字即可，我理解的是“循环的栅栏”
什么是栅栏？
就是拦在你前面的一个障碍物，这个障碍物你一个人推不开，得多叫几个兄弟一起来推才行，推开了才能继续往前走。
public class CyclicBarrierTest {
public static void main(String[] args) {
CyclicBarrier cb = new CyclicBarrier(10, () -> {
// todo：人齐了该干嘛
System.out.println("人齐了，开冲");
});
for (int i = 0; i < 10; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "已就位");
try {
// 线程都在这里等着，直到人气才会执行 CyclicBarrier 里面的方法
cb.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}, i + " 号兄弟").start();
}
}
}
运行结果：
和 CountDownLatch 不同的是，CyclicBarrier 还有个 Cyclic ，我相信你已经猜到了，我们启动 20 个线程看看
门闩是一次性的，当门闩全部取下来这个门就打开了，而栅栏是有弹性的，当人满了把它推开后，它又弹回来把路又堵住了，又需要 n 个人才能把栅栏推开。
如果有小伙伴感兴趣可以去看下它是怎么实现循环的
Semaphore
Semaphore 的意思是：信号量，信号量在线程同步中也是很常见的，你可以把它看作是一个 计数器 cnt
- 当 cnt > 0 说明还有资源
- 当 cnt < 0 说明没有资源了
举个栗子：比如办公室有一台打印机，但是今天领导让大家写一份加薪报告，大家都忙着用这台打印机打印自己的报告，准备今晚加餐吃鸡腿。
public class SemaphoreTest {
public static void main(String[] args) {
// 只有一台打印机
Semaphore s = new Semaphore(1);
for (int i = 0; i < 20; i++) {
new Thread(() -> {
try {
// 去抢打印机（不一定抢得到）
s.acquire();
System.out.println(Thread.currentThread().getName() + " 拿到打印机了，今晚可以加鸡腿了");
// 把打印机还回去
s.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "员工 " + i).start();
}
}
}
输出结果：
**Semaphore **适用于资源有限，消费者无限的场景，比如打印机就是一个很好的例子。
因为我初始化的资源是 1 ，所以会让你觉得和 锁 差不多，其实不然
资源还可以初始化为 10 20 50 100.... 你可能想到了什么，没错，就是限流！
有大量的请求进来，我们只允许我们指定的数量请求进行处理，更多的用途就等以后你来开发了
ReadWriteLock
读写锁
读锁：也就是共享锁，这把锁允许多个线程持有
写锁：也就是独占锁，这把锁只允许一个线程拥有
说人话的意思就是：读不加锁，写加锁
我们都知道加锁的效率会比较低，如果我们只是对资源进行读取，其实是没有线程安全的问题，这时候再加锁就显得有点脱了裤子放屁（多此一举）
所以我们就有了读写锁：读不加锁，写加锁
public class ReadWriteLockTest {
private static final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
// 读写锁通过 ReentrantReadWriteLock 实例进行创建，说明读写锁也是可重入的
private static final ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
private static final ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
public static void main(String[] args) {
ReadWriteLockTest o = new ReadWriteLockTest();
// 先把 写方法注释掉，模拟读操作
for (int i = 0; i < 10; i++) {
new Thread(() -> {
read();
//write();
}, "线程" + i).start();
}
}
public static void read() {
// 上读锁
readLock.lock();
try {
System.out.println(Thread.currentThread().getName() + " 开始读取数据");
System.out.println(Thread.currentThread().getName() + " 读取数据成功");
} finally {
readLock.unlock();
}
}
public static void write() {
writeLock.lock();
try {
System.out.println(Thread.currentThread().getName() + "开始写入数据");
System.out.println(Thread.currentThread().getName() + "写入数据成功");
} finally {
writeLock.unlock();
}
}
}
读操作结果：
我们可以看到执行顺序，线程 8 还没读取成功，线程 9 又在读取数据了。
写操作结果：
我们可以看到，虽然线程不是顺序执行的，但是 新的线程 一定是 等上一个线程写入成功后，自己才开始写如数据
也就是说，开始写入和写入成功永远是成对出现。
BlockingQueue
阻塞队列：相信大家对 Java 中的容器一定不陌生，容器又分了两类：Collection && Map
Collection 中的 List && Set ** **大家都已经耳熟能详了，但是 Queue 可能很少用到
但是我可以告诉你，Queue 的重要程度丝毫不亚于你所知道另外几种
BlockingQueue 更是 线程池 和 MQ 发展的基石
复习一下 Queue，Queue 是一个队列：从尾进，从头出（先进先出）
Queue 给我们提供了几个API：
- add() 添加一个元素，队列满则报错
- offer() 添加一个元素，队列满不报错
- poll() 移除队头元素
- peek() 获取队头元素
而BlockingQueue 给我们提供了几个阻塞的API：
- put() 往队列里面放元素，如果队列满，就一直等着（阻塞），直到队列空出来位置。
- take() 往队列里面取元素，如果队列为空，就一直等着（阻塞），直到队列有元素加进来
还记得线程池核心参数中的任务队列吗？就是让我们传入一个 BlockingQueue
BlockingQueue 分为有界和无界两种：
- 有界： ArrayBlockingQueue （数组实现，要指定数组长度，当然有界啦）
- 无界：LinkedBlockingQueue（链表实现，新任务直接挂在尾节点上，当然就无界了）
说了这么多，我们浅写一个 生产者/消费者 模型：
public class BlockingQueueTest {
public static void main(String[] args) {
// 实例化一个容量为 5 的 BlockingQueue
ArrayBlockingQueue<Integer> abq = new ArrayBlockingQueue<>(5);
new Thread(() -> {
for (int i = 0; i < 20; i++) {
try {
abq.put(i);
System.out.println("生产者生产数据：" + i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
new Thread(() -> {
for (int i = 0; i < 20; i++) {
try {
Integer take = abq.take();
System.out.println("消费者消费数据：" + take);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
运行结果：
这就是一个简单的 MQ
SynchronousQueue
SynchronousQueue 是一个很特殊的 BlockingQueue，特殊在：
它是没有容量，也就是说：生产者把生产出来的数据，手把手递给消费者才算完成
conclusion
其实还有 DelayQueue（延时队列），TransferQueue（控制生产者生产速率用) ... 没有讲，今天我累了 TAT，下节准备分享一下 线程池相关的知识，铁铁们，点个赞再走吧。