上文我们了解了多线程案例中的单例模式，此文我们来探讨多线程案例之阻塞队列吧
1. 阻塞队列是什么？
阻塞队列是⼀种特殊的队列.也遵守"先进先出"的原则.
阻塞队列是⼀种线程安全的数据结构,并且具有以下特性:
- 当队列满的时候,继续⼊队列就会阻塞,直到有其他线程从队列中取⾛元素.
- 当队列空的时候,继续出队列也会阻塞,直到有其他线程往队列中插⼊元素.
阻塞队列的⼀个典型应用场景就是"生产者消费者模型".这是⼀种非常典型的开发模型
那么什么是生产者消费者模型呢？？
1.1 生产者消费者模型
- 生产者消费者模式就是通过⼀个容器来解决生产者和消费者的
强耦合问题
生产者和消费者彼此之间不直接通讯，而是通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找⽣产者要数据，而是直接从阻塞队列⾥取.
应用场景：
一对夫妻开包子店，早上夫妻二人包包子，女的负责擀包子皮（擀好的包子皮放在桌板上（类似于阻塞队列）），男的负责包包子，其中擀包子皮的就是生产者，包包子的就是消费者。擀包子皮的人不在意谁消耗他生产出来的包子皮，包包子的人也不在意是谁生产的包子皮，能用就可以
- 阻塞队列就相当于⼀个缓冲区，平衡了⽣产者和消费者的处理能⼒.
(削峰填⾕）
应用场景：
在每年的双十一、双十二购物节，服务器同⼀时刻可能会收到大量的支付请求，如果同时处理这些支付请求服务器可能扛不住(每个支付请求的处理都需要比较复杂的流程).
这个时候就可以把这些请求都放到⼀个阻塞队列中(类似于上面提到的放包子皮的桌板，消费者不需要按照生产者的请求速度来完成，可以按照自己的速度来完成，就保证了不会服务器崩掉),
然后再由消费者线程慢慢的来处理每个⽀付请求.这样做可以有效进⾏ "削峰", 防⽌服务器被突然到来的⼀波请求直接冲垮.
- 阻塞队列可以实现异步操作
1.2 标准库中的阻塞队列
在 Java 标准库中内置了阻塞队列. 如果我们需要在⼀些程序中使⽤阻塞队列, 直接使⽤标准库中的即可.
BlockingQueue是⼀个接口. 真正实现的类是LinkedBlockingQueue.- put 方法用于阻塞式的入队列, take 用于阻塞式的出队列.
- BlockingQueue 也有 offer, poll, peek 等方法, 但是这些方法不带有阻塞特性.
1.3 消息队列的自我实现
- 首先我们采用的是循环队列的方式实现消息队列
定义一个数组用于存放消息
定义一个头尾指针标记消息队列的队头和队尾
定义一个size用于标记有效数据个数
java
//定义一个消息队列数组
private Integer [] information=null;
//定义一个头指针
private int head=0;
//尾指针
private int tail=0;
//定义一个size用于标记有效数据个数
private int size=0;- 此时我们数组不给定大小，我们采用构造方法在初始化时，给定数组大小，此时和JDK实现的雷同
java
//构造方法用于初始化消息队列的容量大小
public MyBlockQueue(Integer capacity) {
if(capacity<=0){
throw new RuntimeException("队列容量必须大于0.");
}
information=new Integer[capacity];
}
- 在队尾插入元素
为了实现消息队列的效果，就要与普通队列不一样 在插入元素时，
若消息队列满了，就等待，等到消息队列有空位时，就会被唤醒
当插入元素时，就唤醒出元素的的操作
其中，wait()方法、notifyAll()需要搭配synchronize关键字使用
java
public void put(int value) throws InterruptedException {
//没有位置就要等待
if(size>=information.length){
synchronized (this){
this.wait();
}
}
//有位置直接插入元素，无需等待
if(size<information.length){
information[tail]=value;
tail++;
size++;
if(tail>=information.length){
tail=0;
}
synchronized (this){
this.notifyAll();
}
}
}- 在队头出元素
为了实现消息队列的效果，当消息队列中没有元素时，就需要等待，直到有元素进来，再被唤醒
当出元素时，有位置空余出来，就可以唤醒要插入的操作
java
//取出元素
public int take() throws InterruptedException {
//队列为空，需要等待
if(size==0){
synchronized (this){
this.wait();
}
}
//有元素直接取出即可
Integer value=information[head];
head++;
size--;
if(head==information.length){
head=0;
}
synchronized (this){
this.notifyAll();
}
return value;
}- synchronize关键字实现了原子性、在效果上实现了内存可见性，但是没有保证有序性，所以我们
为涉及修改的变量加上volatile关键字
java
//定义一个消息队列数组
private volatile Integer [] information=null;
//定义一个头指针
private volatile int head=0;
//尾指针
private volatile int tail=0;
//定义一个size用于标记有效数据个数
private volatile int size=0;- 由于在插入和删除的操作中涉及多个变量的修改，我们可以扩大synchronize的范围
此时，我们完整的代码如下：
java
public class MyBlockQueue {
//定义一个消息队列数组
private volatile Integer [] information=null;
//定义一个头指针
private volatile int head=0;
//尾指针
private volatile int tail=0;
//定义一个size用于标记有效数据个数
private volatile int size=0;
//构造方法用于初始化消息队列的容量大小
public MyBlockQueue(Integer capacity) {
if(capacity<=0){
throw new RuntimeException("队列容量必须大于0.");
}
information=new Integer[capacity];
}
//插入元素
public void put(int value) throws InterruptedException {
synchronized (this){
//没有位置就要等待
if(size>=information.length){
this.wait();
}
//有位置直接插入元素，无需等待
if(size<information.length){
information[tail]=value;
tail++;
size++;
if(tail>=information.length){
tail=0;
}
synchronized (this){
this.notifyAll();
}
}
}
}
//取出元素
public int take() throws InterruptedException {
synchronized (this){
//队列为空，需要等待
if(size==0){
synchronized (this){
this.wait();
}
}
//有元素直接取出即可
Integer value=information[head];
head++;
size--;
if(head==information.length){
head=0;
}
this.notifyAll();
return value;
}
}
} - 此时引发一个新问题，假设此时有多个线程要进行put操作，但只有一个空余位置，会有什么问题吗
所以我们将if判断改成while判断，并且在JDK提供的put方法中也是用while
1.4 消息队列代码
java
public class MyBlockQueue {
//定义一个消息队列数组
private volatile Integer [] information=null;
//定义一个头指针
private volatile int head=0;
//尾指针
private volatile int tail=0;
//定义一个size用于标记有效数据个数
private volatile int size=0;
//构造方法用于初始化消息队列的容量大小
public MyBlockQueue(Integer capacity) {
if(capacity<=0){
throw new RuntimeException("队列容量必须大于0.");
}
information=new Integer[capacity];
}
//插入元素
public void put(int value) throws InterruptedException {
synchronized (this){
//此处最好使⽤ while.
//否则notifyAll 的时候, 该线程从wait 中被唤醒, 但是紧接着并未抢占到锁.
//当锁被抢占的时候, 可能⼜已经队列满了
while (size>=information.length){
this.wait();
}
information[tail]=value;
tail++;
size++;
if (tail>information.length){
tail=0;
}
this.notifyAll();
}
}
//取出元素
public int take() throws InterruptedException {
synchronized (this){
//队列为空，需要等待
while (size==0){
this.wait();
}
//有元素直接取出即可
Integer value=information[head];
head++;
size--;
if(head==information.length){
head=0;
}
this.notifyAll();
return value;
}
}
}希望得到你的支持，谢谢！