Java 多线程5——阻塞式队列BlockingQueue的原理 + 消费者生产者模型 + 代码模拟实现
文章目录
- 前言
- 一、阻塞式队列是什么？
- 二、生产者消费者模型
-
- 什么是生产者消费者模型
- 生产者消费者模型的益处
- 三、标准库中的阻塞式队列
-
- 阻塞式队列实现生产者消费者模型：
- 阻塞式队列的特性
-
- 队列空时
- 队列满时
- 四、代码模拟实现阻塞式队列
- 总结
前言
本人是一个刚刚上路的IT新兵,菜鸟!分享一点自己的见解,如果有错误的地方欢迎各位大佬莅临指导,如果这篇文章可以帮助到你,劳请大家点赞转发支持一下!
本篇文章分享的内容主要是阻塞式队列，以及代码模拟实现阻塞式队列。
一、阻塞式队列是什么？
阻塞队列是一种特殊的队列. 也遵守 “先进先出” 的原则。
阻塞队列能是一种线程安全的数据结构, 并且具有以下特性：
- ✨当队列满的时候, 继续入队列就会阻塞, 直到有其他线程从队列中取走元素。
- ✨当队列空的时候, 继续出队列也会阻塞, 直到有其他线程往队列中插入元素。
阻塞队列的一个典型应用场景就是 “生产者消费者模型”，这是一种非常典型的开发模型。
二、生产者消费者模型
什么是生产者消费者模型
生产者消费者模式就是通过一个容器来解决生产者和消费者的 强耦合 问题。（耦合的大概意思是指模块之间的依赖程度，耦合程度越低越好，避免代码之间牵一发而动全身）想详细了解可以去大佬博客学习，附大佬博客：什么是耦合性？
生产者消费者模型的益处
生产者与消费者直接通讯
这是四个消费者向生产者服务器发出请求，假如是一万个，十万个，一亿个消费者向生产者服务器发出请求，那么服务器还能承受住吗？？
因此阻塞式队列就发挥他的作用了。
生产者和消费者彼此之间不直接通讯，而通过阻塞式队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞式队列，消费者不找生产者要数据，而是直接从阻塞式队列里取。
-
阻塞式队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
比如在 “抢演唱会门票” 场景下, 服务器在同一时刻可能会收到大量的支付购票请求，如果直接处理这些支付购票请求，服务器可能扛不住(每个支付购票请求的处理都需要比较复杂的流程). 这个时候就可以把这些请求都放到一个阻塞队列中, 然后再由消费者线程慢慢的来处理每个支付购票请求。 -
阻塞式队列也能使生产者和消费者之间 解耦和。
就比如，饭店后厨里的洗菜工和切菜工，洗菜工只负责洗菜，切菜工只负责切洗好的菜。
洗菜工就是"生产者"，切菜工就是"消费者"。
洗菜工不关心切菜工用什么切（能切就行，无论是用菜刀切，用武士刀切，用水果刀切），切菜工也不关心洗菜工用什么洗菜（能洗就行，无论是用凉水洗，用热水洗，用洗菜机洗）。
三、标准库中的阻塞式队列
在 Java 标准库中内置了阻塞队列. 如果我们需要在一些程序中使用阻塞队列, 直接使用标准库中的即可。
BlockingQueue 是一个接口，真正实现的类有 链式存储的LinkedBlockingQueue 与 顺序存储的ArrayBlockingQueue 。
put 方法用于阻塞式的入队列, take 用于阻塞式的出队列。
BlockingQueue 也有 offer, poll, peek 等方法, 但是这些方法不带有阻塞特性。
阻塞式队列实现生产者消费者模型：
public static void main(String[] args) {
BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<>();
// 生产者模型
Thread thread1 = new Thread(() -> {
int value = 0;
while (true) {
try {
// 入队列
blockingQueue.put(value);
System.out.println("生产者：" + value);
value++;
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// 消费者模型
Thread thread2 = new Thread(() -> {
while (true) {
try {
// 出队列
int value = blockingQueue.take();
System.out.println("消费者：" + value);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread1.start();
thread2.start();
}
运行结果：
阻塞式队列的特性
队列空时
public static void main(String[] args) throws InterruptedException {
BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<>();
// 生产者模型
Thread thread1 = new Thread(() -> {
int value = 0;
while (true) {
try {
// 入队列
blockingQueue.put(value);
System.out.println("生产者：" + value);
value++;
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// 消费者模型
Thread thread2 = new Thread(() -> {
while (true) {
try {
System.out.println("消费者来消费了");
// 出队列
int value = blockingQueue.take();
System.out.println("消费者：" + value);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread2.start();
// 先启动消费者模型线程，后启动生产者线程
Thread.sleep(3000);
thread1.start();
}
运行结果：
原因：消费者模型线程先运行的，当消费者模型线程运行到
"int value = blockingQueue.take();"这个语句时，阻塞队列里是空的，因为线程会在这个语句进行阻塞等待。
这是take()方法的源代码
如果队列里数据个数为0则调用await方法。（await方法与wait方法类似）当有数据入队列时，再唤醒这个线程。
队列满时
如果不手动设置队列容量大小，那么他就是整数类型的最大值。
public static void main(String[] args) throws InterruptedException {
// 设置阻塞式队列容量大小为5
BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<>(5);
// 生产者模型
Thread thread1 = new Thread(() -> {
int value = 0;
while (true) {
try {
// 入队列
blockingQueue.put(value);
System.out.println("生产者：" + value);
value++;
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// 只启动生产者模型
thread1.start();
}
运行结果：
队列满了之后，就会等待，等待有数据出队列后，再往队列里存。
四、代码模拟实现阻塞式队列
public class MyBlockingQueue {
// 阻塞队列
// 使用循环队列
// 设置队列大小为1000
private int[] items = new int[1000];
volatile private int head = 0;// 队首下标
volatile private int tail = 0;// 队尾下标
volatile public int size = 0;// 数据个数
// 入队列
synchronized public void put(int elem) throws InterruptedException {
// 可能有多个线程调用put方法，
// 因此该队列的最后一个空位可能会被其他线程先占用，
// 因此要用while来循环判断。
while (size == items.length) {
// 队列满了，阻塞等待
this.wait();
}
// 把新元素放入tail队尾位置
items[tail] = elem;
// 更新tail位置
tail++;
// tail到达数组末尾，从0开始
if(tail == items.length) {
tail = 0;
}
// 更新数据个数
size++;
// 唤醒线程
this.notify();
}
// 出队列
synchronized public Integer take() throws InterruptedException {
// 1.可能有多个线程调用take方法，
// 因此该数据可能会被其他线程先取得。
// 2.wait方法可能是被其他方法中断，
// 代码就不会符合预期结果
// 因此要用while来循环判断。
while (size == 0) {
// 队列为空，阻塞等待
this.wait();
}
// 出队head队首下标数据
int value = items[head];
head++;
// head到达数组末尾，从0开始
if(head == items.length) {
head = 0;
}
// 更新数据个数
size--;
// 唤醒线程
this.notify();
// 出队列
return value;
}
public static void main(String[] args) {
MyBlockingQueue queue = new MyBlockingQueue();
// 生产者
Thread thread1 = new Thread(()->{
int value = 0;
while (true) {
try {
queue.put(value);
System.out.println("生产:" + value);
value++;
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// 消费者
Thread thread2 = new Thread(()->{
while (true) {
try {
int value = queue.take();
System.out.println("消费:" + value);
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread1.start();
thread2.start();
}
}
总结
以上就是今天要分享的内容，本文介绍了多线程中的阻塞式队列，他可以有效的帮助代码模块之间进行解耦和，可以大大提高编写与修改多线程代码的效率，如果帮助到你了，那么就打赏作者点赞收藏加关注吧！
路漫漫不止修身，也养性。