2023.10.21 关于阻塞队列-CSDN博客

本文链接：https://blog.csdn.net/weixin_63888301/article/details/133961366

阻塞队列

优先级队列（Priority Queue）

阻塞队列（Blocking Queue）

消息队列（Message Queue）

阻塞队列

队列最基本的原则为先进先出

优先级队列（Priority Queue）

该队列为一种特殊的队列数据结构
每个元素都有一个与之相关联的优先级
在优先级队列中，元素按照优先级的顺序进行插入和删除操作，优先级高的元素先被处理
所以通常情况下优先级队列的实现使用堆数据结构

阻塞队列（Blocking Queue）

该队列也是特殊的队列
虽然也遵循先进先出的原则，但带有特殊的功能：阻塞
当一个线程试图对空队列进行取元素操作时，它会被阻塞，直到有另一个线程向队列中插入了一个元素
当一个线程试图向满队列中插入元素时，它会被阻塞，直到有另一个线程取走了一个元素，释放了空间

消息队列（Message Queue）

该队列也属于特殊的队列
相当于是在阻塞队列的基础上，加上了个消息的类型按照制定类别进行先进先出

因为消息队列很好用，所以就有大佬把这样的数据结构，单独实现成了一个程序
这个程序可以通过网络的方式和其他程序进行通信
有时这个消息队列，可以单独部署到一组服务器上（分布式）
此时其存储能力和转发能力都大大提升了
因此很多大型项目里，都可以看到消息队列的身影
此时消息队列，就已经成为了一个可以和 mysql，redis 这种相提并论的一个重要组件，也就是 "中间件"
rabbit mq 就是消息队列中的一种典型实现

生产者消费者模型

消息队列之所以很好用，这与阻塞队列的阻塞特性有很大的关系
基于这样的特性，可以实现生产者消费者模型

生产者消费者模型的两个好处

好处一：实现了发送方和接收方之间的解耦

此时A 把请求转发个 B处理，B 处理完把结果反馈给A
此时可以视为 A调用了B
在上述场景中，A和 B之间的耦合是比较高的
A要调用B ，A务必要知道 B的存在
如果 B挂了，很容易引起 A的 bug

如果要是再加一个 C服务器，此时也需要对 A修改不少代码
因此就需要针对 A重新修改代码、重新测试、重新发布、重新部署等，十分麻烦

使用生产者消费者模型解耦

此时A 和B 之间的耦合就降低了很多
A 并不知道B，A只知道队列（A的代码中没有任何一行与 B相关）
B 也不知道A，B只知道队列（B的代码中没有任何一行与 A相关）
如果 B挂了，对 A没有任何影响，因为队列在，A 仍然可以给队列插入元素，如果队列满了，就先阻塞
如果 A挂了，对 B没有任何影响，因为队列在，B仍然可以从队列中取元素，如果队列空了，就先阻塞
新增一个服务器C 来作为消费者，对于 A来说是无感知的

好处二：可以做到削峰填谷，保证系统的稳定性

我们进行服务器开发，也和上述这个模型是非常相似的
上游就是用户发送的请求
下游就是一些执行具体业务的服务器
用户发多少请求是不可控的

标准库阻塞队列使用

import java.util.concurrent.*;

//阻塞队列的使用
public class ThreadDemo21 {
    public static void main(String[] args) throws InterruptedException {
//        基于链表实现的阻塞队列
        BlockingQueue<String> blockingQueue1 = new LinkedBlockingQueue<>();

//        基于数组实现的优先级队列
//        BlockingQueue<String> blockingQueue2 = new ArrayBlockingQueue<>();
//        基于堆实现的优先级队列
//        BlockingQueue<String> blockingQueue3 = new PriorityBlockingQueue<>();

        blockingQueue1.put("hello");
        String res = blockingQueue1.take();
        System.out.println(res);
        res = blockingQueue1.take();
        System.out.println(res);
    }
}

我们向阻塞队列中使用 put 方法插入了一个 "hello" 字符串
此时我们再连续使用两次 take 方法取出阻塞队列中元素
注意此时的 put 方法和 take 方法均带有阻塞功能

运行结果：

我们可以发现控制台打印插入的 "hello" 字符串
当执行第二次 take 方法时，便进行阻塞

实现一个简单生产者消费者模型

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ThreadDemo22 {
    public static void main(String[] args) {
        BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<>();

//        创建两个线程来作为 生产者 和 消费者
        Thread customer = new Thread(() -> {
            while (true) {
                try {
                    Integer result  = blockingQueue.take();
                    System.out.println("消费元素：" + result);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        customer.start();


        Thread producer = new Thread(() -> {
            int count = 0;
            while (true) {
                try {
                    blockingQueue.put(count);
                    System.out.println("生产元素：" + count);
                    count++;
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        producer.start();
    }
}

运行结果：

自己实现阻塞队列代码

以下是基于一个循环数组实现的阻塞队列
//自己写阻塞队列
//此处不考虑泛型，直接使用 int 来表示元素类型
class MyBlockingQueue {
    private int[] items = new int[10];
//    指向阻塞队列的头部
    private int head = 0;
//    指向阻塞队列的尾部
    private int tail = 0;
//    记录阻塞队列的长度
    private int size = 0;

//    入队列
    public void put(int value) throws InterruptedException {
        synchronized (this) {
            while (size == items.length) {
//            队列满了 此时需要阻塞
//                return;
                this.wait();
            }
            items[tail] = value;
            tail++;
//        针对 tail 的处理
//        1.
//        tail = tail % items.length
//        2.
            if(tail >= items.length) {
                tail = 0;
            }
            size++;
//            用来唤醒 take 中的 wait
            this.notify();
        }
    }

//    出队列
    public Integer take() throws InterruptedException {
        int result = 0;
        synchronized (this) {
            while (size == 0) {
    //            队列为空 应该进行阻塞
//                return null;
                this.wait();
            }
            result = items[head];
            head++;
            if (head >= items.length) {
                head = 0;
            }
            size--;
//            唤醒 put 中的 wait
            this.notify();
        }
        return result;
    }
}

public class ThreadDemo23 {
    public static void main(String[] args) throws InterruptedException {
        MyBlockingQueue queue = new MyBlockingQueue();

        Thread product = new Thread(() ->{
            int count = 0;
            while (true) {
                try {
                    System.out.println("生产元素 : " + count);
                    queue.put(count);
                    count++;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        product.start();

        Thread custom = new Thread(() -> {
            int result = 0;
            while (true) {
                try {
                    result = queue.take();
                    System.out.println("消费元素 : " + result);
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        custom.start();
    }
}
运行结果：

重点理解

正因为生产者消费者模型是边生产边消费的
所以上述阻塞队列我们可以基于一个循环数组
那么当我们的 tail 指向数组末尾时，便需要重新指向开头，此时便有两种方案
方案一根据 tail 的值和阻塞队列的长度来取模
方案二直接将 tail 值与数组长度进行比较，如果等于或大于数组长度，直接赋值为 0，也就相当于直接从头开始
更推荐第二种方案
首先第二种方案要更加直观，可读性更好，一眼便能知道该段代码的逻辑是什么
其次取模运算本质上要做一系列的除法运算，计算机算乘除相对算加减是要慢的，但是方案二仅是判定和赋值，这两个高效操作，从而方案二的效率比方案一要高

为了实现 put 方法和 take 方法的阻塞效果，我们引入了 wait 和 notify
在仅创建一个阻塞队列实例的情况下，那么这个两个线程中的 wait 是否会同时触发？
肯定是不会的，针对同一个阻塞队列，不可能既是空又是满

此处当队列满或队列空时，将会直接进入 wait 阻塞状态
那为什么这里是写的循环，而不是写 if 判断语句呢？
具体来说就是当 wait 被 notify 唤醒后，阻塞队列一定是非空或不满吗？
咱们当前的代码确实不会出现这种情况
因为该代码一定是插入或拿取元素成功后才会 notify 唤醒 wait
并不存在第二种唤醒 wait 的方式，所以 wait 不会在非空或不满的时候被唤醒
但是为了稳妥起见，还是加上 while 循环唤醒之后，再判定一下，看此时的条件是否具备

正如上述 wait 原码中建议写法一致