并发容器：手写一个阻塞队列

已于 2022-02-16 17:55:06 修改
阅读量887 收藏 1
点赞数
分类专栏： 并发 文章标签： 容器 java 运维
于 2018-06-08 23:59:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzti_erlie/article/details/80629458
版权

在这里插入图片描述

Java中提供的阻塞队列

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。

  1. 支持阻塞的插入方法：意思是当队列满时，队列会阻塞插入的元素，直到队列不满
  2. 支持阻塞的移除方法：意思是在队列为空时，获取元素的线程会等待队列变为非空

阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者从队列里取元素的线程。阻塞队列就是生产者用来存放元素，消费者用来获取元素的容器

插入和移除操作的4种处理方式

方法/处理方式抛出异常
Queue接口		返回特殊值
Queue接口		一直阻塞
BlockingQueue接口		超时退出
BlockingQueue接口
插入方法boolean add©boolean offer(e)void put(e)boolean offer(e, time, unit)
解释添加元素，添加成功返回true，如果队列满了，抛出IllegalStateException添加元素，添加成功返回true，如果队列满了，返回false添加元素，如果队列已经满了，则阻塞等待添加元素，添加成功返回true，如果队列已经满了，则阻塞等待，指定时间已经过去还没能添加成功元素，则返回false
移除方法E remove()E poll()E take()E poll(time, unit)
解释返回头结点，从队列中移除头节点，如果队列为空，抛出NoSuchElementException返回头结点，从队列中移除头节点，如果队列为空，返回null返回头结点，从队列中移除头节点，如果队列为空则阻塞等待返回头结点，从队列中移除头节点，队列中没元素会一直阻塞等待，指定时间已经过去还没能拿到头节点，则返回null
检查方法E element()E peek()不可用不可用
解释返回头结点，但是不从队列中移除头节点，如果队列为空，抛出NoSuchElementException返回头结点，但是不从队列中移除头节点，如果队列为空，返回null

用等待/通知协调生产者和消费者

举一个多生产者，多消费者的例子，队列的大小为3，即队列大小为3时，生产者就不再生产

public class Producer implements Runnable {

    private ArrayList list;

    private int capacity;

    public Producer(ArrayList queue,int capacity) {
        this.list = queue;
        this.capacity = capacity;
    }

    @Override
    public void run() {
        synchronized (list) {
            while (true) {
                while (list.size() == capacity) {
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Object object = list.add(new Object());
                System.out.println(Thread.currentThread().getName() + " 生产");
                list.notifyAll();
            }
        }
    }
}

注意消费者和生产者都是用的notifyAll()[通知所有阻塞的线程]方法，而不是notify()[通知一个阻塞的线程]方法，因为有可能出现“生产者”唤醒“生产者”，消费者“唤醒”消费者的情况，因此有可能造成死锁。

这里以1个消费者，3个生产者为例说一下，消费者1获得锁还没产品呢，阻塞，接着生产者1获得锁生产完了，然后生产者2获得锁后生产完了，再然后生产者3获得锁生产完了，最后生产者1获得锁了，然后阻塞了，现在好了生产者和消费者都阻塞了，造成了死锁。notifyAll()则不会造成死锁，接着上面的步骤，生产者3生产完了释放锁后，会通知所有阻塞的线程，因此消费者1肯定有机会拿到锁来进行消费

public class Consumer implements Runnable {

    private List list;

    public Consumer(List queue) {
        this.list = queue;
    }

    @Override
    public void run() {
        synchronized (list) {
            while (true) {
                while (list.size() == 0) {
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Object object = list.remove(0);
                System.out.println(Thread.currentThread().getName() + " 消费");
                list.notifyAll();
            }
        }
    }
}

public class Test {

    public static void main(String[] args) {

        ArrayList list = new ArrayList(3);
        for (int i = 0; i < 3; i++) {
            new Thread(new Producer(list, 3), "生产者" + i).start();
            new Thread(new Consumer(list), "消费者" + i).start();
        }
    }
}

一部分结果

生产者0 生产
生产者0 生产
生产者0 生产
消费者1 消费
消费者1 消费
消费者1 消费
生产者1 生产

把这个实例用阻塞队列来改写，先自己写一个阻塞队列，实现BlockingQueue接口，这里只展示了一部分重写的方法

public class MyBlockingQueue<E> implements BlockingQueue<E> {

    private int capacity;
    private List<E> list;

    public MyBlockingQueue(int capacity) {
        this.capacity = capacity;
        this.list = new ArrayList(capacity);
    }

    @Override
    public void put(E e) throws InterruptedException {
        synchronized (this) {
            if (list.size() == capacity) {
                this.wait();
            }
            list.add(e);
            this.notifyAll();
        }
    }

    @Override
    public E take() throws InterruptedException {
        synchronized (this) {
            while (list.size() == 0) {
                this.wait();
            }
            E value = list.remove(0);
            this.notifyAll();
            return value;
        }
    }

}

public class Producer implements Runnable {

    private BlockingQueue queue;

    public Producer(BlockingQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                queue.put(new Object());
                System.out.println(Thread.currentThread().getName() + " 生产");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Consumer implements Runnable {

    private BlockingQueue queue;

    public Consumer(BlockingQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Object object = queue.take();
                System.out.println(Thread.currentThread().getName() + " 消费");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Test {

    public static void main(String[] args) {
        BlockingQueue queue = new MyBlockingQueue(3);
        for (int i = 0; i < 3; i++) {
            new Thread(new Producer(queue), "生产者" + i).start();
            new Thread(new Consumer(queue), "消费者" + i).start();
        }
    }
}

这里将BlockingQueue的实现改为ArrayBlockingQueue，程序运行结果一样，和我们之前的例子比较，BlockingQueue其实就是不用我们自己写阻塞和唤醒的部分，直接看一下ArrayBlockingQueue的源码，其实和我自己实现的差不多，只不过是并发这部分源码用的是ReentLock，而我用的是synchronized

ArrayBlockingQueue

在这里插入图片描述

设置notEmpty和notFull2个Condition用来实现线程通信

// 设置同步队列的大小和锁是否公平
public ArrayBlockingQueue(int capacity, boolean fair) {
	if (capacity <= 0)
		throw new IllegalArgumentException();
	this.items = new Object[capacity];
	lock = new ReentrantLock(fair);
	notEmpty = lock.newCondition();
	notFull =  lock.newCondition();
}

往阻塞队列中放元素，当放满时，将线程阻塞到notFull这个等待队列。
可以正常放入阻塞队列中时，则唤醒notEmpty中的线程，让其消费元素

public void put(E e) throws InterruptedException {
	checkNotNull(e);
	final ReentrantLock lock = this.lock;
	lock.lockInterruptibly();
	try {
		while (count == items.length)
			notFull.await();
		enqueue(e);
	} finally {
		lock.unlock();
	}
}

private void enqueue(E x) {
	// assert lock.getHoldCount() == 1;
	// assert items[putIndex] == null;
	final Object[] items = this.items;
	items[putIndex] = x;
	// 循环数组实现
	if (++putIndex == items.length)
		putIndex = 0;
	count++;
	notEmpty.signal();
}

从阻塞队列中获取元素时，如果为空，则将线程阻塞到notEmpty这个等待队列。不为空，从阻塞队列取到元素时，还需要唤醒notFull中的线程，让其往阻塞队列中放元素

public E take() throws InterruptedException {
	final ReentrantLock lock = this.lock;
	lock.lockInterruptibly();
	try {
		while (count == 0)
			notEmpty.await();
		return dequeue();
	} finally {
		lock.unlock();
	}
}

private E dequeue() {
	// assert lock.getHoldCount() == 1;
	// assert items[takeIndex] != null;
	final Object[] items = this.items;
	@SuppressWarnings("unchecked")
	E x = (E) items[takeIndex];
	items[takeIndex] = null;
	// 放到数组的最后一个了，下一次从头开始放
	if (++takeIndex == items.length)
		takeIndex = 0;
	count--;
	if (itrs != null)
		//更新iterators，不再分析
		itrs.elementDequeued();
	notFull.signal();
	return x;
}

最后说一下LZ的理解，个人感觉用ArrayBlockingQueue实现生产者和消费者，比我上面用synchronized的方式应该快很多，毕竟ArrayBlockingQueue只会是生成者通知消费者，或者消费者通知生产者，而synchronized不是，会造成很多不必要的锁竞争，当然并没有实验，有时间可以试试

参考博客

[1]https://blog.csdn.net/luohuacanyue/article/details/16359777
[2]https://www.cnblogs.com/chentingk/p/6497107.html
[3]https://www.cnblogs.com/Ming8006/p/7243858.html
实现阻塞队列
[4]https://blog.csdn.net/truelove12358/article/details/59597169
[5]https://blog.csdn.net/z83986976/article/details/52017259

Java识堂
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
BlockingQueue（阻塞队列）详解
weixin_30478923的博客
04-24 2754
注意：该随笔内容完全引自http://wsmajunfeng.iteye.com/blog/1629354，写的很好，非常感谢，复制过来算是个积累，怕以后找不到。 一. 前言 　　在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了Blo...
Java并发编程：阻塞队列
01-20
　使用非阻塞队列的时候有一个很大问题是：它不会对当前线程产生阻塞，那么在面对类似消费者-生产者的模型时，必须额外地实现同步策略以及线程间唤醒策略，这个实现起来非常麻烦。但是有了阻塞队列不一样了，它会
Rocketmq源码解读之消息拉取
weixin_33795093的博客
06-12 176
最近阅读了Rocketmq关于pullmessage的实现方式，分享出来 众所周知，Rocketmq在consumer端是拉取消息的方式，它会在客户端维护一个PullRequestQueue，这个是一个阻塞队列（LinkedBlockingQueue），内部的节点是PullRequest，每一个PullRequest代表了一个消费的分组单元 PullRequest会记录一个topi...
RocketMQ中的线程池是如何创建的？
m0_71777195的博客
12-15 1545
大家好，我是小郭，今天主要来和大家聊一聊RocketMQ中的线程池是如何创建的，如何设置线程池数量，同时也可以从中去学习到一些线程池的实践和需要注意的一些细节。
RocketMQ 自己的整理和理解
LzwGlory的专栏
11-18 3582
每个人的想法不同， RocketMQ 介绍的时候就说 是阿里从他们使用的上 解耦出来 近一步简化 便捷的 目的当然是 让其能快速入手和开发 如果不是在项目设计层面上 只是使用的话 从Git上下载该项目的源码 其中有一个包是专门的测试 实例的 只需要照猫画虎 使用就可以了 不能有中文路径！ 不能有中文路径！ 不能有中文路径！ 关系 两个接口
Java并发编程：同步容器
12-22
为了方便编写出线程安全的程序，Java里面提供了一些线程安全类和并发工具，比如：同步容器、并发容器、阻塞队列、Synchronizer（比如CountDownLatch）。我们来讨论下同步容器。 　一.为什么会出现同步容器？ 　在...
linux中编写自己的并发队列类(Queue 并发阻塞队列)
01-10
设计并发队列 代码如下:#include <pthread>#include <list>using namespace std; template <typename>class Queue { public: Queue( ) { pthread_mutex_init(&_lock, NULL); } ~Queue( ) { pthread_mutex_destroy(&...
Java并发：同步容器&并发容器
12-22
第一节 同步容器、并发容器 　1.简述同步容器与并发容器 　在Java并发编程中，经常听到同步容器、并发容器之说，那什么是同步容器与并发容器呢？同步容器可以简单地理解为通过synchronized来实现同步的容器，比如...
进程资源图a和b
ronghwa_lu
04-23 3459
进程资源图 知识点 进程资源图如图(a)和(b)所示，其中：图(a)中（ ）；图(b)中（ ）。（2013年上半年） A.P1是非阻塞节点，P2是阻塞节点，所以该图不可以化简，是死锁的 B.P1、P2都是阻塞节点，所以该图不可以化简，是死锁的 C.P1、P2都是非阻塞节点，所以该图可以化简，是非死锁的 D.P1是阻塞节点，P2是非阻塞节点，所以该图不可以化简、是死锁的 A.P1、P2、P3都是非阻塞节点，该图可以化简，是非死锁的 B.P1、P2、P3都是阻塞节点，该图不可以化简，是死锁的 C.P2是阻塞节
Java中什么方法导致线程阻塞
Chin_Style的博客
03-24 3万+
一、为什么引入线程阻塞机制？ 为了解决对共享存储区的访问冲突，Java 引入了同步机制，现在让我们来考察多个线程对共享资源的访问，显然同步机制已经不够了，因为在任意时刻所要求的资源不一定已经准备好了被访问，反过来，同一时刻准备好了的资源也可能不止一个。为了解决这种情况下的访问控制问题，Java 引入了对阻塞机制的支持。 阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪），学过操作系...
redis必问
David_bdqn的博客
11-22 2913
redis是非关系内存键值对数据库，类似于HashMap; 五种数据类型：String、list、hash、set、zset 内存中数据持久化 使用复制来扩展读性能：复制到多台服务器、提高读性能和可用性 使用分区来扩展写性能（hash一致性算法）：当数据量大的时候，把数据分散存入多个数据库中，减少单节点的连接压力； 特点：完全基于内存；多路I/O复用模型； Redis和Memcache有什么区别 Redis的线程模型是什么？ Redis的数据类型及应用场景？ Redis的持久化策略有哪些？
科目一：信息系统综合知识——3.操作系统知识
将如何存在的博客
06-27 574
3.1 操作系统概述 作用：通过资源管理提高计算机系统的效率，改善人机界面向用户提供友好的工作环境。 特征：并发性、共享性、虚拟性、不确定性。 功能：进程管理、存储管理、文件管理、设备管理、作业管理。 分类：批处理操作系统、分时操作系统（时间片）、实时操作系统（快速响应）、网络操作系统、分布式操作系统、微机操作系统、嵌入式操作系统。 计算机启动的基本流程：BIOS->主引导记录->操作系统 3.2 进程管理 3.2.1 进程的组成和状态 进程：进程控制块PCB(唯一标志)、程序、数据 三态
vue axios 阻塞未完成请求
牛马程序员进阶之路
04-07 2834
import _ from 'lodash' import axios from 'axios' const { CancelToken, Cancel } = axios const tokens = {} /** * 请求前处理 config（尽可能在最先注册的拦截器中调用） * @param {import('axios').AxiosRequestConfig} config */ export const setConfig = function(config) { const { .
解决:Rabbitmq 消息队列阻塞的问题
谢伟光的博客
05-14 1万+
接收消息的正确代码 /** * 接收消息 */ override fun receiveMessage(queue: String, onMessageReceiveListener: OnMessageReceiveListener) { if (!ensureChannelOpen()) return try { ...
深入理解阻塞队列（一）——基本结构
xingfeng_coder的博客
05-31 9235
BlockingQueue是一个继承自Queue的接口，在Queue的队列基础上增加了阻塞操作。简单来说，就是在在BlockingQueue为空时从队头取数据将会被阻塞，因为此时还没有数据可取，一旦队列中有数据了，取数据的线程就会释放得到了数据；如果BlockingQueue有容量限制且满了，那么插入数据的线程将会阻塞，知道队列中有空闲位置可以插入数据了，才会释放。经过上面一段描述，可以发现这不就是
消息队列 | RocketMq某些队列阻塞不消费
sharedCode源码交流
12-03 6678
公司小伙伴反馈自己负责的RocketMq集群忽然有两个队列不消费了，消息堆积达到了1万多条，这个肯定不正常。 以下是当时的消费组的实际消费情况 从上面的图中可以看出来，有两个队列严重阻塞了，好久没有上报过offset了。 通过以往自己的经验，一般来说，RocketMq部分队列消费失败，主要有以下三个原因 消费者的集群数量有问题，比如之前笔者有写过一篇文章，也是介绍RocketMq部分队列不能正常消费的，有兴趣的可以看看RocketMq 部分队列不能消费问题排查 消费者的consumer group乱用，
阻塞队列BlockQueue的方法含义
jack_shuai的博客
10-28 389
public boolean add(E e) 方法将抛出IllegalStateException异常，说明队列已满。 public boolean offer(E e) 方法则不会抛异常，只会返回boolean值，告诉你添加成功与否，队列已满，当然返回false。 public void put(E e) throws InterruptedException 方法则一直阻塞（即等待，直到...
深入剖析java并发之阻塞队列LinkedBlockingQueue与ArrayBlockingQueue
热门推荐
zejian的博客
08-31 9万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/77410889 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
一个并发的队列C++程序
最新发布
09-11
队列是一种先进先出（FIFO）的数据结构。在并发编程中，队列可用于在多个线程之间传递信息或任务。 下面是一个简单的 C 语言队列程序的例子： ``` #include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <stdbool.h> #define QUEUE_SIZE 10 // 队列数据结构 typedef struct { int items[QUEUE_SIZE]; // 存储元素的数组 int front; // 队列头 int rear; // 队列尾 int count; // 队列中元素的个数 pthread_mutex_t lock; // 互斥锁 } queue; // 初始化队列 void queue_init(queue *q) { q->front = 0; q->rear = -1; q->count = 0; pthread_mutex_init(&q->lock, NULL); } // 向队列中添加元素 void queue_add(queue *q, int item) { // 使用互斥锁保证线程安全 pthread_mutex_lock(&q->lock); // 如果队列已满，则扩大数组 if (q->count == QUEUE_SIZE) { int new_size = QUEUE_SIZE * 2; q->items = realloc(q->items, new_size * sizeof(int)); QUEUE_SIZE = new_size; } // 将元素添加到队列尾部 q->rear = (q->rear + 1) % QUEUE_SIZE; q->items[q->rear] = item; q->count++; pthread_mutex_unlock(&q->lock); } // 从队列中删除元素 int queue_remove(queue *q) { // 使用互斥锁保证线程安全 pthread_mutex_lock(&q->lock); // 如果队列为空，则返回 -1 if (q->count == 0) { p

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Java识堂

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值