【Java to Architect】Blocking Queue 阻塞队列应对并发

最新推荐文章于 2023-08-09 12:42:35 发布
最新推荐文章于 2023-08-09 12:42:35 发布
阅读量123 收藏 1
点赞数
分类专栏： java - 0 to architect 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35714301/article/details/112390376
版权

概论

Blocking Queue（阻塞队列）

  1. 试图从空队列出列的线程会被阻塞，直到另一个线程将某个项目添加到队列中。
  2. 试图添加到满队列的线程会被阻塞，直到另一个线程将某个项目弹出队列。

阻塞队列是并发友好的。

阻塞队列类型（从有界无界角度）

  1. 无界阻塞队列（unbounded）
  2. 有界阻塞队列（bounded）
无界阻塞队列
BlockingQueue<String> blockingQueue = new LinkedBlockingDeque<>()

无界阻塞队列的容量为`Integer.MAX_VALUE，任何添加项目的线程操作都不会被阻塞，因此，无界阻塞队列的大小可能会变得无比巨大。

在生产-消费模型中，如果选择了无界队列，需要注意的是，消费者的消费操作必须很快，不然由于无界，很可能导致OOM错误。

有界阻塞队列
BlockingQueue<String> blockingQueue = new LinkedBlockingDeque<>(10);

此队列的容量为10，当队列的项目数量为10时，当生产者继续添加项目，生产者的行为将被阻塞，直到有队列重新得到控件。

在设计并发程序时，使用有界阻塞队列的好处是，不需要其他操作，就可以让程序节流。

阻塞队列接口

根据最终的行为结果来分类，有两类接口：

  1. 添加项目（生产）
  2. 弹出、回收项目（消费）
添加
  • add() - 添加成功则返回 true，失败则抛出illegalStateException异常
  • put() - 添加元素，必要时会等待队列腾出空余位子
  • offer() - 添加成功返回 true，失败则返回 false
  • offer(E e, long timeout, TimeUnit unit) - 为添加行为设定一个等待时间上限，若超时则放弃添加
回收
  • take() - 若队列有可用元素则弹出该元素，若队列为空，则等待有可用元素
  • poll(long timeout, TimeUnit unit) - 为弹出元素行为设定一个时间上限，当超时时，返回 null

生产-消费模型例子

在这个例子中：

  • 生产者生产0-20的数字，放入10个位子的有界阻塞队列中
  • 消费者消费数字
  • 当消费者得到特殊数字，则消费者停止消费

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadLocalRandom;

public class BlockingQueueDemo {
    public static void testDemo() {
        class NumbersProducer implements Runnable {
            private BlockingQueue<Integer> numbersQueue;

            public NumbersProducer(BlockingQueue<Integer> numbersQueue) {
                this.numbersQueue = numbersQueue;
            }

            public void run() {
                try {
                    while (true) {
                        System.out.println("producer is producing...");
                        numbersQueue.put(ThreadLocalRandom.current().nextInt(100));
                        System.out.println("produced. Now the queue is: " + numbersQueue);
                        Thread.sleep(300);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }

        class NumbersConsumer implements Runnable {
            private BlockingQueue<Integer> queue;
            private final int poisonPill;

            public NumbersConsumer(BlockingQueue<Integer> queue, int poisonPill) {
                this.queue = queue;
                this.poisonPill = poisonPill;
            }

            public void run() {
                try {
                    while (true) {
                        System.out.println("Consumer start to consume...");
                        Integer number = queue.take();
                        System.out.println("Consumed. Consumed number is: " + number + ". queue contains" + queue);
                        if (number.equals(poisonPill)) {
                            System.out.println("got the poisonPill: " + poisonPill);
                            return;
                        }
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
        int BOUND = 10;
        int poisonPill = ThreadLocalRandom.current().nextInt(20);

        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(BOUND);

        ExecutorService service = Executors.newCachedThreadPool();
        NumbersProducer producer = new NumbersProducer(queue);
        NumbersConsumer consumer = new NumbersConsumer(queue, poisonPill);
        System.out.println("THE POISON IS: " + poisonPill);
        service.submit(producer);
        service.submit(consumer);
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {

        }
        service.shutdownNow();
    }

    public static void main(String[] args) {
        BlockingQueueDemo.testDemo();
    }
}

运行代码之后，得到的日志如下：
producer is producing…
Consumer start to consume…
produced. Now the queue is: [63]
Consumed. Consumed number is: 63. queue contains[]
producer is producing…
produced. Now the queue is: [53]
producer is producing…
produced. Now the queue is: [53, 35]
producer is producing…
produced. Now the queue is: [53, 35, 66]
Consumer start to consume…
Consumed. Consumed number is: 53. queue contains[35, 66]
producer is producing…
produced. Now the queue is: [35, 66, 85]
producer is producing…
produced. Now the queue is: [35, 66, 85, 21]
producer is producing…
produced. Now the queue is: [35, 66, 85, 21, 14]
Consumer start to consume…
Consumed. Consumed number is: 35. queue contains[66, 85, 21, 14]
producer is producing…
produced. Now the queue is: [66, 85, 21, 14, 86]
producer is producing…
produced. Now the queue is: [66, 85, 21, 14, 86, 12]
producer is producing…
produced. Now the queue is: [66, 85, 21, 14, 86, 12, 47]
Consumer start to consume…
Consumed. Consumed number is: 66. queue contains[85, 21, 14, 86, 12, 47]
producer is producing…
produced. Now the queue is: [85, 21, 14, 86, 12, 47, 45]
producer is producing…
produced. Now the queue is: [85, 21, 14, 86, 12, 47, 45, 40]
producer is producing…
produced. Now the queue is: [85, 21, 14, 86, 12, 47, 45, 40, 90]
producer is producing…
produced. Now the queue is: [85, 21, 14, 86, 12, 47, 45, 40, 90, 34]
Consumer start to consume…
Consumed. Consumed number is: 85. queue contains[21, 14, 86, 12, 47, 45, 40, 90, 34]
producer is producing…
produced. Now the queue is: [21, 14, 86, 12, 47, 45, 40, 90, 34, 53]
producer is producing…
Consumer start to consume…
Consumed. Consumed number is: 21. queue contains[14, 86, 12, 47, 45, 40, 90, 34, 53]
produced. Now the queue is: [14, 86, 12, 47, 45, 40, 90, 34, 53, 80]
Consumer start to consume…
Consumed. Consumed number is: 14. queue contains[86, 12, 47, 45, 40, 90, 34, 53, 80, 37]
produced. Now the queue is: [86, 12, 47, 45, 40, 90, 34, 53, 80, 37]
producer is producing…
Consumer start to consume…
Consumed. Consumed number is: 86. queue contains[12, 47, 45, 40, 90, 34, 53, 80, 37]
produced. Now the queue is: [12, 47, 45, 40, 90, 34, 53, 80, 37, 73]
producer is producing…
Consumer start to consume…
Consumed. Consumed number is: 12. queue contains[47, 45, 40, 90, 34, 53, 80, 37, 73]
produced. Now the queue is: [47, 45, 40, 90, 34, 53, 80, 37, 73, 85]
producer is producing…
Consumer start to consume…
Consumed. Consumed number is: 47. queue contains[45, 40, 90, 34, 53, 80, 37, 73, 85]
produced. Now the queue is: [45, 40, 90, 34, 53, 80, 37, 73, 85, 95]
producer is producing…
PS E:\Achi> e:; cd ‘e:\Achi’; & ‘c:\Users\Administrator.vscode\extensions\vscjava.vscode-java-debug-0.30.0\scripts\launcher.bat’ ‘C:\Program Files\Java\jdk-11\bin\java.exe’ ‘-Dfile.encoding=UTF-8’ ‘@C:\Users\ADMINI~1\AppData\Local\Temp\cp_7l3ntbr8klh7dvqwh3tsamibj.argfile’ ‘blockingQueue.BlockingQueueDemo’
THE POISON IS: 10
producer is producing…
Consumer start to consume…
produced. Now the queue is: []
Consumed. Consumed number is: 57. queue contains[]
producer is producing…
produced. Now the queue is: [72]
producer is producing…
produced. Now the queue is: [72, 89]
producer is producing…
produced. Now the queue is: [72, 89, 10]
Consumer start to consume…
Consumed. Consumed number is: 72. queue contains[89, 10]
producer is producing…
produced. Now the queue is: [89, 10, 91]
producer is producing…
produced. Now the queue is: [89, 10, 91, 41]
producer is producing…
produced. Now the queue is: [89, 10, 91, 41, 9]
Consumer start to consume…
Consumed. Consumed number is: 89. queue contains[10, 91, 41, 9]
producer is producing…
produced. Now the queue is: [10, 91, 41, 9, 40]
producer is producing…
produced. Now the queue is: [10, 91, 41, 9, 40, 12]
producer is producing…
produced. Now the queue is: [10, 91, 41, 9, 40, 12, 35]
Consumer start to consume…
Consumed. Consumed number is: 10. queue contains[91, 41, 9, 40, 12, 35]
got the poisonPill: 10
producer is producing…
produced. Now the queue is: [91, 41, 9, 40, 12, 35, 86]
producer is producing…
produced. Now the queue is: [91, 41, 9, 40, 12, 35, 86, 66]
producer is producing…
produced. Now the queue is: [91, 41, 9, 40, 12, 35, 86, 66, 95]
producer is producing…
produced. Now the queue is: [91, 41, 9, 40, 12, 35, 86, 66, 95, 1]
producer is producing…

Fala Oviara
关注
专栏目录
【Java多线程】JUC之线程池(六)手写阻塞队列
墩墩分墩
11-23 697
**区别：** 1. 当队列是空的时，从队列中`读元素`的操作将会被`阻塞`，**即试图从空的阻塞队列中读元素的线程将会被阻塞，直到其他的线程往空的队列写入新的元素。** 2. 当队列是满时，往队列里`写元素`的操作会被`阻塞`。**即试图往已满的阻塞队列中写元素的线程同样也会被阻塞，直到其他的线程读元素使队列重新变得空闲起来。** **原理:** 阻塞队列就是通过 "生产-消费者模型" 实现的，**当队列为空时，消费者挂起，队列已满时，生产者挂起**。阻塞其实就是`将线程挂起。` **场景:*
Java并发编程 之阻塞队列
const_
11-15 234
文章目录阻塞队列阻塞队列好处 阻塞队列 阻塞队列，顾名思义，首先它是一个队列，而一个阻塞队列在数据结构中所起的作用大致如图所示： 线程1往阻塞队列中添加元素，线程2从阻塞队列中移除元素。 当阻塞队列是空时，从队列中获取元素的操作将会被阻塞。 当阻塞队列是满时，往队列中添加元素的操作将会被阻塞。 试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。 同样 试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他线程从队列中移除一个或者多个元素或者完全清空队列后使队列重新
java手写一个阻塞队列
corlor_龙的博客
04-24 449
import java.util.LinkedList; import java.util.List; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * @program: * @description: 手写一个阻塞队列 * @author: colorful *
手写JDK组件之阻塞队列BlockedQueue
weixin_30312563的博客
08-20 254
研究了一段时间框架，有点审美疲劳，今天讲点轻松的，手写一个阻塞队列，实践一把lock+condition。 “等待通知”机制 首先复习一下经典的 “等待通知”机制。 线程首先获取互斥锁，当线程要求的条件不满足时，释放互斥锁，进入等待状态；当要求的条件满足时，通知等待的线程，重新获取互斥锁 --《极客时间-Java并发编程实战》 在Java中实现 “等待通知” 机制一般有两种方式，s...
java 手写阻塞队列_实现Java 阻塞队列
weixin_39836943的博客
12-21 140
实现Java 阻塞队列在自己实现之前先搞清楚阻塞队列的几个特点：基本队列特性：先进先出。写入队列空间不可用时会阻塞。获取队列数据时当队列为空时将阻塞。实现队列的方式多种，总的来说就是数组和链表；其实我们只需要搞清楚其中一个即可，不同的特性主要表现为数组和链表的区别。这里的 ArrayBlockingQueue 看名字很明显是由数组实现。我们先根据它这三个特性尝试自己实现试试。初始化队列我这里自定义...
Java_Architect_Notes-John_H.rar_architect_java architect
09-24
【Java架构师笔记——John_H】是一份...通过深入学习【Java_Architect_Notes-John_H】中的内容，并结合实际项目经验，备考者将能够系统地掌握Java架构设计的各个环节，为成功通过Java架构师认证考试打下坚实的基础。
Java_Architect_Notes-Balaji.rar_java architect
09-24
3. **并发与性能优化**：Java的并发编程模型，包括线程池、锁机制（如synchronized和Lock）、原子类、并发容器（如ConcurrentHashMap）等，以及如何进行性能调优，都是Java架构师必须掌握的技能。 4. **框架与库**...
java-architect:Java Architect学习代码和注释
03-31
本资源“java-architect:Java Architect学习代码和注释”显然是为了帮助那些希望提升为Java架构师或者已经在该职位上的人准备的。下面将详细探讨涉及的知识点。 1. **Java编程基础**： - 对Java语法的全面理解，...
Microservices for Java EE Architects Addendum for The Java EE Architect's epub
01-18
Microservices for Java EE Architects Addendum for The Java EE Architect's Handbook 英文epub 本资源转载自网络，如有侵权，请联系上传者或csdn删除 查看此书详细信息请在美国亚马逊官网搜索此书
java8源码-java_architect:java_架构师
06-04
Java中的队列都有哪些，有什么区别。 Java的内存模型以及GC算法 Java8的新特性 Java数组和链表两种结构的操作效率，在哪些情况下(从开头开始，从结尾开始，从中间开始)，哪些操作(插入，查找，删除)的效率高？ Java...
java 手写阻塞队列_手写阻塞队列（Condition实现）
weixin_39717825的博客
12-21 200
自己实现阻塞队列的话可以采用Object下的wait和notify方法，也可以使用Lock锁提供的Condition来实现，本文就是自己手撸的一个简单的阻塞队列，部分借鉴了JDK的源码。Ps：最近看面经的时候发现字节跳动的面试官特别喜欢让面试者手写阻塞队列，希望本文能对大家有帮助。个人手撸如有错误还请批评指正。public class AxinBlockQueue {//队列容器private L...
java 手写阻塞队列_JAVA实现阻塞队列
weixin_39732716的博客
12-21 161
package 多线程并发;import java.util.Stack;/*** Created by z84102272 on 2018/7/17.*/public class BlockQueueImpl {private final static Object pushLock = new Object(); //push的锁private final static Object pop...
手写阻塞队列（java）
最新发布
青鱼入云的博客
08-09 207
手动实现一个阻塞队列。
基于wait/notify的阻塞队列
qq_22158743的博客
05-19 431
阻塞队列与普通的队列的区别就是当队列为空或者满时处理的逻辑不通，普通队列返回特殊值（比如null，false等等）而阻塞队列是阻塞当前线程直到队列有元素或者不为空。 下面我们使用Java中的wait/notify方法来实现一个自己的阻塞队列。 首先定义阻塞队列的接口： public interface BlockingQueue<E>{ /** * 往队列尾部...
手写阻塞队列
qq_36245532的博客
09-03 262
自己实现阻塞队列的话可以采用Object下的wait和notify方法，也可以使用Lock锁提供的Condition来实现，本文就是自己手撸的一个简单的阻塞队列。最近面试京东时遇到让实现阻塞队列的思路，希望本文能对大家有帮助。个人手撸如有错误还请批评指正。 public class BoundedBlockQueue { // 队列容器 private LinkedList<Object> buffer; private int maxSize; ...
java 手写阻塞队列_Java中阻塞队列的使用
weixin_39730671的博客
01-04 95
在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。认识BlockingQueue阻塞队列，顾名思义，首先它是一个队列，而一个队列在数据结构中所起的作用大致如下图...
第十一篇 队列的学习（三） 手写一个阻塞队列
码农飞哥
02-07 2057
本文我们手写了一个阻塞队列，队列的数据结构采用数组来实现。队列的阻塞功能分别用了`synchronized(this)`、`this.wait()`、`this.notifyAll()`的方式和`ReentrantLock`和`Condition`的`await()`以及`signalAll()`和`signal()`两种方式来实现阻塞功能，本质上就是生产者-消费者模型。。在JDK中ArrayBlockingQueue实现队列阻塞就是通过`ReentrantLock`和`Condition`的`await(
并发容器：手写一个阻塞队列
小识的博客
06-08 927
前言 阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。 支持阻塞的插入方法：意思是当队列满时，队列会阻塞插入的元素，直到队列不满 支持阻塞的移除方法：意思是在队列为空时，获取元素的线程会等待队列变为非空 阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者从队列里取元素的线程。阻塞队列就是生产者用来存放元素，消费者用来获取元素的容器 插入和移除操作的4种处理方式 方法/处理方式 抛出异常 返回特殊值 一直阻塞 超
Retrofit原理解析
qq_34290971的博客
11-09 465
一、定义 Retrofit是一个网络请求封装框架，默认使用OkHttp进行网络请求，只是简化了用户的网络请求参数的封装。 二、使用 1.创建Retrofit实例 2.定义网络请求接口，并为接口中的方法添加相应的注解 3.通过动态代理生成网络请求对象 4.通过网络请求适配器将网络请求对象进行平台适配 5.通过网络清执行器，发送网络请求 6.通过数据解析器解析数据 7.通过回调执行器，切换线程 8.用户在主线程处理返回数据 网络接口 public interface WanAndroi
Java EE认证考试指南：Sun Certified Enterprise Architect
"Sun Certified Enterprise Architect for J2EE Study Guide 是一本针对2010年发布的Java 2 EE认证考试的最新教材。本书由Mark Cade和Humphrey Sheil合著，旨在帮助读者准备并成功通过Sun Microsystems的Java企业...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值