【Java多线程】【阻塞队列】

最新推荐文章于 2024-06-24 19:52:40 发布
最新推荐文章于 2024-06-24 19:52:40 发布
阅读量799 收藏 5
点赞数 4
分类专栏： Java多线程 文章标签： java 开发语言 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OTO233/article/details/132051880
版权

目录

1、概念

1.1 什么是阻塞队列

1.2 特性 

2、生产者消费者模型 

 2.1 解耦合

2.2 削峰填谷 

 2.3 模型实现

3、阻塞队列  方法及实现

3.1 方法

3.2 核心 

3.3 实现 

3.3.1 普通队列

 3.3.2 加上阻塞

1、概念

1.1 什么是阻塞队列

从名字上 可以看出，它是队列的一种，那肯定是 先进先出（FIFO）的数据结构

1.2 特性 

  1. 阻塞添加：当阻塞队列是满时，继续 添加的操作将被阻塞，直到被其他线程从队列取走元素
  2. 阻塞移除：当阻塞队列是空时，继续 获取的操作将被阻塞，直到被其他线程从队列添加元素

在多线程中，多线程之间进行数据交互，可以使用阻塞队列简化代码实现

应用场景：

  1. 线程池的底层存储
  2. 生产者消费者模型

下面详细讲解 生产者消费者模型

2、生产者消费者模型 

这是一种常用的并发式编程模型，用于解决生产者和消费者之间的数据传输和同步问题

组成：

  1. 生产者：负责生成数据并将其存储在共享数据结构中（阻塞队列）
  2. 消费者：负责从共享数据结构中获取并进行处理
  3. 共享数据结构：一般为阻塞队列实现

生产者往阻塞队列中插入数据，消费者从阻塞队列取出数据，队列的阻塞性可以实现生产者和消费者之间的同步和互斥

 生活中的例子 擀饺子皮（生产者）、包饺子（消费者），放饺子皮（阻塞队列）

 2.1 解耦合

可以让上下游模块之间，进行更好的“解耦合”

耦合：两个或多组模块之间的依赖关系

 问题：高耦合

解决： 引入阻塞队列，作为数据传输点

2.2 削峰填谷 

问题：传输的数据、速度直接影响，超出限度可能出现问题

解决：削峰填谷 

 2.3 模型实现

 public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> bq = new LinkedBlockingQueue<>();
        //消费者
        Thread consumer = new Thread(()->{
            while (true){
                try {
                    int value = bq.take();
                    System.out.println("消费元素："+value);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        consumer.start();
        //生产者
        Thread producer = new Thread(()->{
            int value = 0;
            while (true){
                try {
                    System.out.println("生产元素："+value);
                    bq.put(value);
                    value++;
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //生产一个元素 消费一个元素
        producer.start();
    }

3、阻塞队列  方法及实现

3.1 方法

方法类型

抛出异常

返会布尔

阻塞

插入

add()

offer()

put()

取出

remove()

poll()

take()

队首

element()

peek()

无

注意：

  1. BlockingQueue 是一个接口. 真正实现的类是 LinkedBlockingQueue.
  2. put 方法用于阻塞式的入队列, take 用于阻塞式的出队列
  3. BlockingQueue 也有 offer, poll, peek 等方法, 但是这些方法不带有阻塞特性.

3.2 核心 

 阻塞队列核心 两个方法 put() 和 take()

 public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> bq1 = new LinkedBlockingQueue<>();
        //阻塞队列核心 两个方法  put() 和 take()
        //put() 阻塞放入
        bq1.put(1);
        bq1.put(2);
        bq1.put(3);
        bq1.put(4);
        bq1.put(5);
        //take() 取出
        System.out.println(bq1.take());
        System.out.println(bq1.take());
        System.out.println(bq1.take());
        System.out.println(bq1.take());
        System.out.println(bq1.take());
        //已经全部取出
        //再取 就进入阻塞等待  
        System.out.println(bq1.take());
    }
}

3.3 实现 

步骤：

  1. 先实现一个普通队列
  2. 加上阻塞功能
  3. 加上线程安全

3.3.1 普通队列

 实现循环 单向队列，取出和存放

class MyBlockingQueue{
    //数组  存储数据
    private  int[] elem = new int[1000];
    //头尾
    private int head = 0;
    private int tail = 0;
    //有效数据
    private int useSize = 0;

    //put  添加
    public void put(int value){
        //判满
        if(useSize == elem.length){
            return;
        }
        //添加  放到尾坐标上
        elem[tail] = value;
        tail++;
        //放到最后 从头开始
        if(tail == elem.length){
            tail = 0;
        }
        useSize++;
    }
    //take 移除
    public int put(){
        //判空
        if(useSize == 0){
            return -1;
        }
        //从头 取出
        int value = elem[head];
        head++;
        //取到尾 从头开始
        if(head == elem.length){
            head = 0;
        }
        useSize--;
        return value;
    }
}

 3.3.2 加上阻塞

  1. 加阻塞 wait 和 notify 前提是 加锁
  2. 存放 put() ，满就等待 wait，进入阻塞，等待取出，notify唤醒
  3. 取出 take()，空就等待 wait，进入阻塞，等待存放，notify唤醒
 //put  阻塞添加
    synchronized public void put(int value) throws InterruptedException {
        //判满
        if(useSize == elem.length){
            //return;
            //等待取出
            this.wait();
        }
        //添加  放到尾坐标上
        elem[tail] = value;
        tail++;
        //放到最后 从头开始
        if(tail == elem.length){
            tail = 0;
        }
        useSize++;
        //唤醒获取等待
        this.notify();
    }
    //take 阻塞移除
    synchronized public int put() throws InterruptedException {
        //判空
        if(useSize == 0){
            //return -1;
            //等待存放
            this.wait();
        }
        //从头 取出
        int value = elem[head];
        head++;
        //取到尾 从头开始
        if(head == elem.length){
            head = 0;
        }
        useSize--;
        //唤醒存放等待
        this.notify();
        return value;
    }
  1. 上述加上 wait() 和 notify() 虽然可以进入等待 和 唤醒，但是还有一个问题，如果不是norify()唤醒的，其他代码中 interrupt 把wait唤醒了，条件不满足但是继续执行了，那么就会出现错误
  2. 写入操作可能出重排序排序

解决

  1. 提前唤醒，那就在判断一次条件是否满足，将 if 给为 while
  2. 给元素加上 volatile
class MyBlockingQueue{
    //数组  存储数据
    private  int[] elem = new int[1000];
    //头尾
    volatile private int head = 0;
    volatile private int tail = 0;
    //有效数据
    volatile private int useSize = 0;

    //put  阻塞添加
    synchronized public void put(int value) throws InterruptedException {
        //判满
        while(useSize == elem.length){
            //return;
            //等待取出
            this.wait();
        }
        //添加  放到尾坐标上
        elem[tail] = value;
        tail++;
        //放到最后 从头开始
        if(tail == elem.length){
            tail = 0;
        }
        useSize++;
        //唤醒获取等待
        this.notify();
    }
    //take 阻塞移除
    synchronized public Integer take() throws InterruptedException {
        //判空
        while(useSize == 0){
            //return -1;
            //等待存放
            this.wait();
        }
        //从头 取出
        int value = elem[head];
        head++;
        //取到尾 从头开始
        if(head == elem.length){
            head = 0;
        }
        useSize--;
        //唤醒存放等待
        this.notify();
        return value;
    }
}
 public static void main(String[] args) {
        MyBlockingQueue queue = new MyBlockingQueue();
        // 消费者
        Thread t1 = new Thread(() -> {
            while (true) {
                try {
                    int value = queue.take();
                    System.out.println("消费: " + value);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 生产者
        Thread t2 = new Thread(() -> {
            int value = 0;
            while (true) {
                try {
                    System.out.println("生产: " + value);
                    queue.put(value);
                    value++;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();
        t2.start();
 }

 

清元丶
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Java多线程案例之阻塞队列
未见花闻的博客
04-08 4249
本篇文章将介绍Java多线程案例，阻塞队列，阻塞队列在普通队列的基础上多了两种情况，一是阻塞队列为空时，如果进行出队操作，会使当前线程阻塞，直到有新元素插入阻塞队列，该线程才被通知继续执行出队操作；二是阻塞队列为满时，如果进行入队操作，会使当前线程阻塞，直到有元素出队时，该线程才会被通知继续执行入队操作。在实际开发中，常常使用消息队列，而消息队列就是阻塞队列，只是在阻塞队列的基础上增加了很多功能。
java 多线程 队列工厂
08-04
在`queueFactory`压缩包中，可能包含了示例代码或者类库，展示了如何使用队列工厂模式来创建和管理不同类型的队列，特别是针对Java多线程环境的优化。这些资源可以帮助开发者更好地理解和应用多线程和队列技术，提高...
java之阻塞队列（BlockingQueue）
weixin_43824267的博客
01-22 2332
java之阻塞队列一、阻塞队列概念二、阻塞队列的好处三、阻塞队列种类四、BlockingQueue的核心方法五、示例代码1.使用SychronousQueue队列2.传统版生产者消费者模式3.阻塞队列版（以ArrayBlockingQueue为例）生产者消费者模式 一、阻塞队列概念 阻塞队列，顾名思义，首先它是一个队列（先进先出），而一个阻塞队列在数据结构所起到的作用大致如下图： 线程1往阻塞队列中添加元素，而线程2从阻塞队列中移除元素 当阻塞队列是空是，从队列中获取元素的操作会被阻塞 当阻塞队列是满时
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
最新发布
2401_84301352的博客
06-24 438
此外,通过设置有界队列,我们还可以限制队列的最大容量,防止任务无限堆积导致内存溢出。当队列已满时,我们可以采取拒绝策略(如直接丢弃、暂存等)来应对新加入的任务。如下图，任务等待队列其实就是联系任务生成者与任务消费者的一个桥梁，生产者生产消息放入等待队列中，再由消费者拿取消费。
Java线程池和阻塞队列
纯洁的小魔鬼
08-17 3705
一.Java线程池的优点 1.降低资源消耗：通过重复利用线程池中已创建好的线程来降低线程创建和销毁造成的消耗。 2.提高响应速度：当任务到达时，任务可以直接拿到线程池中已创建好的线程立即执行。 3.提高线程的可管理性：线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。 二.ThreadPoolExecutor 1. ThreadPoolExecutor类中共提供四种构造方法： a.拥有五个参数： int corePo..
Java 多线程阻塞队列
weixin_43979290的博客
10-27 210
BlockingQueue 其主要方法及其说明：
第十三章 Java多线程——阻塞队列
qq_42889895的博客
05-11 826
13.1 阻塞队列的由来 我们假设一种场景，生产者一直生产资源，消费者一直消费资源，资源存储在一个缓存池中，生产者将生产的资源存进缓存池中，消费者从缓存池 中拿到资源进行消费，这就是大名鼎鼎的生产者-消费者模式。 该模式能够简化开发过程，一方面消除了生产者与消费者类之间的代码依赖性，另方面将生产数据的过程与使用数据的过程解耦简单化负载。 我们⾃⼰coding实现这个模式的时候，因为需要让多个线程操作共享变量（即资源），所以很容易引发线程安全问题，造成重复消费和死锁，尤其是⽣产者和消费者存在多个的情况。另外，
BlockingQueu 阻塞队列
dizan4060的博客
09-14 291
java.util.concurrent public interface BlockingQueue<E> extends Queue<E> 简介 当阻塞队列插入数据时： 如果队列已经满了，线程则会阻塞等待队列中元素被取出后在插入。 当从阻塞队列中取数据时，如果队列是空的，则线程会阻塞等待队列中有新元素。 阻塞队列（BlockingQueue...
java多线程加队列上传文件_后台处理
05-12
### Java多线程加队列上传文件_后台处理 #### 概述 本文将详细介绍一个基于Java实现的多线程文件上传系统，并结合队列管理技术来优化后台处理流程。该系统通过创建多个线程来并行处理客户端的文件上传请求，同时...
Java中使用阻塞队列控制线程集实例
09-03
总结来说，这个Java程序利用阻塞队列`ArrayBlockingQueue`来协调多线程间的协作，实现了高效、并发的文件搜索功能。这种设计模式在并发编程中非常常见，特别是在需要处理大量数据或者需要进行分布式计算的场景下。...
UDP+阻塞队列+多线程
12-22
总结来说，这个实验通过结合UDP通信、多线程和阻塞队列技术，设计了一个并发运算服务器，实现了对多个客户端请求的高效处理。在处理过程中，还需要注意线程同步和数据一致性问题，以保证服务的稳定性和准确性。
Java多线程并发执行demo代码实例
08-18
"Java多线程并发执行demo代码实例" ...通过这个demo代码实例，我们学习了Java多线程并发执行的实现，包括泛型、线程池、阻塞队列和计数器等概念。这些概念可以帮助开发者编写更加高效、灵活和可重用的代码。
Java 阻塞队列
zy103118的博客
09-25 224
Java 阻塞队列--BlockingQueue 1. 什么是阻塞队列？ 阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。 阻塞队列提供了四种处理方法: 方法\处理方式 抛出异常 返回特殊值 ..
Java阻塞队列
weixin_42189550的博客
12-28 367
1. 常见阻塞队列 1）ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按照FIFO（先进先出）的原则对元素进行排序； 2）LinkedBlockingQueue：一个基于链表结构的有界(大小默认值为Integer.MAX_VALUE)阻塞队列，此队列按照FIFO（先进先出）的原则对元素进行排序，吞吐量通常要高于ArrayBlockingQueue。 3）SynchronousQueue：一个不存储元素的阻塞队列，每个插入操作必须等到另外一个线程调用移除操作，否则插入操作
Java多线程之阻塞队列
再无此人的博客
10-22 164
Java多线程之阻塞队列 Java核心技术卷(10th)读书笔记 对于许多线程问题， 可以通过使用一个或多个队列以优雅且安全的方式将其形式化。生 产者线程向队列插人元素， 消费者线程则取出它们。使用队列，可以安全地从一个线程向另 一个线程传递数据。 当试图向队列添加元素而队列已满， 或是想从队列移出元素而队列为空的时候， 阻塞队 列（blocking queue ) 导致线程阻塞。 在协...
Java线程-阻塞队列
brimen的博客
03-12 433
阻塞队列是Java5线程特征当中新增的内容，Java定义了阻塞队列的接口java.util.concurrent.BlockingQueue。阻塞队列的概念是：如果指定长度的队列满了，添加新元素的操作就会被阻塞等待，直到有空位位置。 有了这样的功能，就为多线程排队等候的模型提供了便捷的通道。 java.util.concurrent.BlockingQueue继承了java.util.Queue接...
阻塞队列
07-13 825
原文地址  By Jakob Jenkov   翻译：寒桐 校对：方腾飞 阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样，试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他的线程使队列重新变得空闲起来，如从
java多线程阻塞队列
09-22
阻塞队列（BlockingQueue）是Java多线程编程中的一个重要概念。它是一个支持在多线程环境下安全地进行数据存取的队列。当阻塞队列为空时，从队列中获取元素的操作将会被阻塞；当阻塞队列满时，往队列中添加元素的操作也将会被阻塞。阻塞队列的原理是利用了线程的等待通知机制，当队列为空或满时，线程会自动挂起或唤醒，从而实现线程安全的数据交换。 使用阻塞队列的优点在于它可以帮助我们自动管理线程的阻塞和唤醒操作，而不需要我们手动去控制这些细节。在Java的并发包中，提供了多种阻塞队列的实现类，例如ArrayBlockingQueue、LinkedBlockingQueue和PriorityBlockingQueue等，可以根据具体需求选择适合的实现类来使用。 阻塞队列在多线程编程中有着广泛的应用场景，例如线程池中使用阻塞队列来管理待执行的任务，生产者消费者模式中使用阻塞队列来实现线程间的数据交换等。通过使用阻塞队列，我们可以简化多线程编程的复杂度，提高代码的可读性和可维护性。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值