阻塞队列和生产者消费者模式的简单实现

梦里梦外; 2023-09-28 23:54 23阅读 0赞

首先自己手动实现一个简单的阻塞队列，然后使用自己写的阻塞队列实现生产者消费者模式，我们需要了解什么是阻塞队列，如下：

**阻塞队列特性：**

1.  当队列满的时候, 继续入队列就会阻塞, 直到有其他线程从队列中取走元素.
2.  当队列空的时候, 继续出队列也会阻塞, 直到有其他线程往队列中插入元素.

**阻塞队列实现步骤：**

1.  实现一个队列
2.  线程安全
3.  阻塞功能

**具体代码：**

//阻塞队列/消息队列的简单实现
    
    public class MyBlockQueue {
        
        int head = 0;
        int tail = 0;
        int[] arr = null;
        int size = 0;
        int len;
    
        public MyBlockQueue(int len) {
        
            this.len = len;
            arr = new int[len];
        }
    
        public synchronized void put(int val) throws InterruptedException {
        
            //如果满了就阻塞
            while (size == len) {
        
                this.wait();
            }
            //没满就插入数据
            arr[tail] = val;
            tail++;
            size++;
            if (tail >= len) {
        
                tail = 0;
            }
            //唤醒其他线程
            this.notify();
        }
    
        public synchronized int take() throws InterruptedException {
        
            //如果为空 则阻塞
            while (size == 0) {
        
                this.wait();
            }
            //不为空则取数据
            int res = arr[head];
            head++;
            size--;
            if (head == len) {
        
                head = 0;`在这里插入代码片`
            }
            //唤醒其他线程 并返回结果
            this.notify();
            return res;
        }
    }

接下来用阻塞队列实现生产者消费者模型。

**具体代码：**

//生产者消费者模型
    
    public class Demo_3 {
        
        public static void main(String[] args) {
        
            MyBlockQueue blockQueue = new MyBlockQueue(6);
            //生产者产生一百个数据
            Thread producer = new Thread(() -> {
        
                try {
        
                    int num = 0;
                    for (int i = 0; i < 100; i++) {
        
                        num++;
                        System.out.println("生产了数据" + num);
                        blockQueue.put(num);
                    }
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            });
            //消费者不断消费数据
            Thread consumer = new Thread(() -> {
        
                try {
        
                    while (true) {
        
                        int num = blockQueue.take();
                        System.out.println("消费了数据" + num);
                    }
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            });
            producer.start();
            consumer.start();
        }
    }

**遇到的问题解释：**

为什么阻塞队列的阻塞功能实现那里判断使用的是while而不是if？

//如果满了就阻塞
            while (size == len) {
        
                this.wait();
            }

//如果为空 则阻塞
            while (size == 0) {
        
                this.wait();
            }

**解答：** **首先wait会让线程进入WAITING状态，且被唤醒之后会从wait处继续执行代码，wait后会释放所拥有的锁。** 若有一个生产者，两个(多个)消费者，如果生产者生产了一个数据。然后调用notifyAll()，唤醒了两个消费者，若我们使用的是if，那么程序接着从wait处执行，那么两个消费者都会从阻塞队列中取数据？但是实际上只有一个数据，这就产生了所谓的**虚假唤醒**。  
![在这里插入图片描述][492e2427a3564072b59588e794e91bf6.png]

如果我们使用的是while，那么程序接着从wait处执行，会**重新while判断**一下是否有数据，第一个获得锁的对象判断为有数据，取出，第二个获得锁的对象接着判断，发现没数据了，继续进入阻塞状态。

[492e2427a3564072b59588e794e91bf6.png]: https://img-blog.csdnimg.cn/492e2427a3564072b59588e794e91bf6.png