从零学习JAVA多线程(四):阻塞队列和生产者消费者模式

经典设计模式之 -- 使用阻塞队列实现“生产者-消费者模型” 自己实现了的阻塞队列,介绍了经典的设计模式“生产者-消费者模型”。 阅读详情

在很多书和博客里,阻塞队列和生产者消费者模式是绑在一起的,好像二者关系是绝对密不可分互为实现方案的,但事实上并不是,生产者消费者模式是多线程编程中常见的解决方案,阻塞队列则是实现生产者消费者方案的一种(较好的)实现方法。
我们就阻塞队列开始讲,然后在生产者和消费者模式的讲解中会给出几种常见的实现方案。

阻塞队列

阻塞队列

阻塞队列(BlockingQueue)是线程安全版本的队列,它支持线程阻塞。当我们向一个空的阻塞队列请求数据的时候,它会阻塞直至有新的数据插入;相对的,如果我们向一个全满的队列中插入数据,它也会阻塞知道有新的位置可供数据插入。

阻塞队列的方法

在阻塞队列中存在以下方法可供使用:

方法正常动作特殊处理
add添加一个元素如果队列满,抛出IllegalStatException异常
element返回队列的头元素如果队列空,抛出NoSuchElementException异常
remove移除并返回队列的头元素如果队列空,抛出NoSuchElementException异常
offer添加一个元素并返回true如果队列满,返回false
peek返回队列的头元素如果队列为空,返回null
poll移除并返回队列的头元素如果队列为空,返回null
put添加一个元素到队列如果队列满,则阻塞
take移除并返回队列的头元素如果队列空,则阻塞

从上面的方法集合里可以看出,BlockingQueue是支持阻塞动作的。

几种阻塞队列的实现

在Java的java.util.concurrent包中,提供了六种Blocking的实现:

  1. LinkedBlockingQueue:由链表结构组成的有界阻塞队列,如果不指定最大容量,则LinkedBlockingQueue是没有上边界的(注意支持的最大长度是 Integer.MAX_VALUE,也可以认为是长度为 Integer.MAX_VALUE的有界队列,只是不需要声明长度)
  2. ArrayBlockingQueue:由数组结构组成的有界阻塞队列。在构造时需要指明容量,还有一个可选参数来设定公平性。如果设定了公平性参数,那么等待时间最长的线程会得到优先处理(会降低性能)
  3. PriorityBlockingQueue:支持优先级排序的无界阻塞队列。队列中的元素会按照优先级顺序被移出。
  4. DelayQueue:只有延时期满才能取出数据的无界阻塞队列。
  5. SynchronousQueue:一个不存储元素的阻塞队列。只有当请求元素时,才允许添加。也就是想要put,必须要对应的take。
  6. LinkedTransferQueue(Java 7增加):基于链表的无界阻塞队列。采用预占模式分配。当有线程来请求元素时,如果队列中有直接拿走,如果没有就标记一下开始等,等到了就走。

生产者和消费者模式

什么是生产者消费者模式

所谓生产者就是一个生产数据(指令)的线程,消费者就是一个消费数据(指令)的线程。生产者不断地产生数据,消费者不断地使用数据,像很多设计模式一样,为了二者的解耦,我们会生成一个缓冲区,这个缓冲区负责接收和推出数据,并且处理数据缺少或者溢出时的特殊情况。
为了形象化这个场景,我们可以设想一下饭店里吃饭做饭的场景:
顾客不断走进来需求新的食物,厨师们不断劳动生产食物。这就是生产者和消费者关系。一般情况下在饭点厨师的生产能力可能跟不上点餐的速度,就会有很多客户等待,这些客户里可能有人等的时间长,有人是熟客或者Vip(优先级高),情况就变得复杂起来。这时候,就出现了服务员(缓冲区),有了服务员,顾客和厨师就不用直接沟通了,厨师也不用记着谁先来谁后到,顾客也不用因为不晓得还要等多久换家店了。点菜上菜记录顺序和偏好都由服务员负责,整个事务场景就会一下子清晰起来。

生产者消费者模式的优点

生产者消费者模式作为一个具有普遍实用性的方案,具有以下的特点;

  1. 解耦:假设生产者和消费者分别是两个类。如果让生产者直接调用消费者的某个方法,那么生产者对于消费者就会产生依赖(也就是耦合)。将来如果消费者的代码发生变化,可能会影响到生产者。而如果两者都依赖于缓冲区,两者之间不直接依赖,耦合也就相应降低了。
  2. 支持并发:生产者直接调用消费者的某个方法,还有另一个弊端。由于函数调用是同步的(或者叫阻塞的),在消费者的方法没有返回之前,生产者只好一直等在那边。万一消费者处理数据很慢,生产者就会白白糟蹋大好时光。
    使用了生产者/消费者模式之后,生产者和消费者可以是两个独立的并发主体(常见并发类型有进程和线程两种,后面的帖子会讲两种并发类型下的应用)。生产者把制造出来的数据往缓冲区一丢,就可以再去生产下一个数据。基本上不用依赖消费者的处理速度。
  3. 支持忙闲不均
    如果制造数据的速度时快时慢,缓冲区的好处就体现出来了。当数据制造快的时候,消费者来不及处理,未处理的数据可以暂时存在缓冲区中。等生产者的制造速度慢下来,消费者再慢慢处理掉。

生产者消费者模式的实现

生产者与消费者模式有几种的实现方案:

  • wait()/notify()实现
  • await()/signal()实现
  • 阻塞队列实现
  • Semaphore实现(较为少见,不做介绍)
  • PipedInputStream / PipedOutputStream(较为少见,不做介绍)

wait()/notify()实现

复习一下wait()和notify()方法。

  • 是Object的公用方法。
  • 调用了wait()方法的线程进入等待状态,直到有别的线程用notify()或者notifyAll()方法唤醒它。被唤醒的线程在重新获得锁之后可以继续执行。
  • notify方法用于唤醒某个等待的线程。

在生产者消费者模式中的作用:

  • wait()方法:当缓冲区已满/空时,生产者/消费者线程停止自己的执行,放弃锁,使自己处于等等状态,让其他线程执行。
  • notify()方法:当生产者/消费者向缓冲区放入/取出一个产品时,向其他等待的线程发出可执行的通知,同时放弃锁,使自己处于等待状态。
    示例代码如下:
    缓冲区:
package com.vivi.myTest.synchronizedTest.produceAndConsume;

import java.util.LinkedList;

/**
 * Created by vivit on 2017/10/16.
 */
public class Storage {
    //    仓库最大容量
    private final int MAX_SIZE = 100;

    //仓库的存储载体
    private LinkedList<Object> list = new LinkedList<>();

    // 生产num个产品
    public void produce(int num) {
        // 同步代码段
        synchronized (list) {
            // 如果仓库剩余容量不足
            while (list.size() + num > MAX_SIZE) {
                System.out.println("【要生产的产品数量】:" + num + "/t【库存量】:"
                        + list.size() + "/t暂时不能执行生产任务!");
                try {
                    // 由于条件不满足,生产阻塞
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 生产条件满足情况下,生产num个产品
            for (int i = 1; i <= num; ++i) {
                list.add(new Object());
            }

            System.out.println("【已经生产产品数】:" + num + "/t【现仓储量为】:" + list.size());

            list.notifyAll();
        }
    }

    // 消费num个产品
    public void consume(int num) {
        // 同步代码段
        synchronized (list) {
            // 如果仓库存储量不足
            while (list.size() < num) {
                System.out.println("【要消费的产品数量】:" + num + "/t【库存量】:"
                        + list.size() + "/t暂时不能执行生产任务!");
                try {
                    // 由于条件不满足,消费阻塞
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // 消费条件满足情况下,消费num个产品
            for (int i = 1; i <= num; ++i) {
                list.remove();
            }

            System.out.println("【已经消费产品数】:" + num + "/t【现仓储量为】:" + list.size());

            list.notifyAll();
        }
    }

    // get/set方法
    public LinkedList<Object> getList() {
        return list;
    }

    public void setList(LinkedList<Object> list) {
        this.list = list;
    }

    public int getMAX_SIZE() {
        return MAX_SIZE;
    }
}

生产者:

package com.vivi.myTest.synchronizedTest.produceAndConsume;

/**
 * Created by vivit on 2017/10/16.
 */
public class Producer extends  Thread{
    private int num;

    // 所在放置的仓库
    private Storage storage;

    // 构造函数,设置仓库
    public Producer(Storage storage) {
        this.storage = storage;
    }

    // 线程run函数
    public void run() {
        produce(num);
    }

    // 调用仓库Storage的生产函数
    public void produce(int num) {
        storage.produce(num);
    }

    // get/set方法
    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public Storage getStorage() {
        return storage;
    }

    public void setStorage(Storage storage) {
        this.storage = storage;
    }
}

消费者

package com.vivi.myTest.synchronizedTest.produceAndConsume;

/**
 * Created by vivit on 2017/10/16.
 */
public class Consumer extends Thread {
    // 每次消费的产品数量
    private int num;

    // 所在放置的仓库
    private Storage storage;

    // 构造函数,设置仓库
    public Consumer(Storage storage) {
        this.storage = storage;
    }

    // 线程run函数
    public void run() {
        consume(num);
    }

    // 调用仓库Storage的生产函数
    public void consume(int num) {
        storage.consume(num);
    }

    // get/set方法
    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public Storage getStorage() {
        return storage;
    }

    public void setStorage(Storage storage) {
        this.storage = storage;
    }
}

测试入口:

package com.vivi.myTest.synchronizedTest.produceAndConsume;

/**
 * Created by vivit on 2017/10/16.
 */
public class TestEntrance {
    public static void main(String[] args) {
        // 仓库对象
        Storage storage = new Storage();

        // 生产者对象
        Producer p1 = new Producer(storage);
        Producer p2 = new Producer(storage);
        Producer p3 = new Producer(storage);
        Producer p4 = new Producer(storage);
        Producer p5 = new Producer(storage);
        Producer p6 = new Producer(storage);
        Producer p7 = new Producer(storage);

        // 消费者对象
        Consumer c1 = new Consumer(storage);
        Consumer c2 = new Consumer(storage);
        Consumer c3 = new Consumer(storage);

        // 设置生产者产品生产数量
        p1.setNum(10);
        p2.setNum(10);
        p3.setNum(10);
        p4.setNum(10);
        p5.setNum(10);
        p6.setNum(10);
        p7.setNum(80);

        // 设置消费者产品消费数量
        c1.setNum(50);
        c2.setNum(20);
        c3.setNum(30);

        // 线程开始执行
        c1.start();
        c2.start();
        c3.start();
        p1.start();
        p2.start();
        p3.start();
        p4.start();
        p5.start();
        p6.start();
        p7.start();
    }
}

打印输出:

【要消费的产品数量】:50/t【库存量】:0/t暂时不能执行生产任务!
【要消费的产品数量】:20/t【库存量】:0/t暂时不能执行生产任务!
【已经生产产品数】:10/t【现仓储量为】:10
【要消费的产品数量】:30/t【库存量】:10/t暂时不能执行生产任务!
【要消费的产品数量】:20/t【库存量】:10/t暂时不能执行生产任务!
【要消费的产品数量】:50/t【库存量】:10/t暂时不能执行生产任务!
【已经生产产品数】:10/t【现仓储量为】:20
【已经生产产品数】:10/t【现仓储量为】:30
【已经生产产品数】:10/t【现仓储量为】:40
【要消费的产品数量】:50/t【库存量】:40/t暂时不能执行生产任务!
【已经消费产品数】:20/t【现仓储量为】:20
【要消费的产品数量】:30/t【库存量】:20/t暂时不能执行生产任务!
【已经生产产品数】:80/t【现仓储量为】:100
【已经消费产品数】:50/t【现仓储量为】:50
【已经生产产品数】:10/t【现仓储量为】:60
【已经生产产品数】:10/t【现仓储量为】:70
【已经消费产品数】:30/t【现仓储量为】:40

await()/signal()实现

因为缓冲区解耦了生产者和消费者的关系,当我们想要替换掉wait()/notify()方法时,只需要修改Storage即可,不需要修改生产者和消费者类。
代码如下:

package com.vivi.myTest.synchronizedTest.produceAndConsume;

import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by vivit on 2017/10/16.
 */
public class StorageWithAwait {
    // 仓库最大存储量
    private final int MAX_SIZE = 100;

    // 仓库存储的载体
    private LinkedList<Object> list = new LinkedList<Object>();

    // 锁
    private final Lock lock = new ReentrantLock();

    // 仓库满的条件变量
    private final Condition full = lock.newCondition();

    // 仓库空的条件变量
    private final Condition empty = lock.newCondition();

    // 生产num个产品
    public void produce(int num)
    {
        // 获得锁
        lock.lock();

        // 如果仓库剩余容量不足
        while (list.size() + num > MAX_SIZE)
        {
            System.out.println("【要生产的产品数量】:" + num + "/t【库存量】:" + list.size()
                    + "/t暂时不能执行生产任务!");
            try
            {
                // 由于条件不满足,生产阻塞
                full.await();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }

        // 生产条件满足情况下,生产num个产品
        for (int i = 1; i <= num; ++i)
        {
            list.add(new Object());
        }

        System.out.println("【已经生产产品数】:" + num + "/t【现仓储量为】:" + list.size());

        // 唤醒其他所有线程
        full.signalAll();
        empty.signalAll();

        // 释放锁
        lock.unlock();
    }

    // 消费num个产品
    public void consume(int num)
    {
        // 获得锁
        lock.lock();

        // 如果仓库存储量不足
        while (list.size() < num)
        {
            System.out.println("【要消费的产品数量】:" + num + "/t【库存量】:" + list.size()
                    + "/t暂时不能执行生产任务!");
            try
            {
                // 由于条件不满足,消费阻塞
                empty.await();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }

        // 消费条件满足情况下,消费num个产品
        for (int i = 1; i <= num; ++i)
        {
            list.remove();
        }

        System.out.println("【已经消费产品数】:" + num + "/t【现仓储量为】:" + list.size());

        // 唤醒其他所有线程
        full.signalAll();
        empty.signalAll();

        // 释放锁
        lock.unlock();
    }

    // set/get方法
    public int getMAX_SIZE()
    {
        return MAX_SIZE;
    }

    public LinkedList<Object> getList()
    {
        return list;
    }

    public void setList(LinkedList<Object> list)
    {
        this.list = list;
    }
}

打印输出

【要消费的产品数量】:50   【库存量】:0 暂时不能执行生产任务!  
【要消费的产品数量】:30   【库存量】:0 暂时不能执行生产任务!  
【已经生产产品数】:10    【现仓储量为】:10  
【已经生产产品数】:10    【现仓储量为】:20  
【要消费的产品数量】:50   【库存量】:20    暂时不能执行生产任务!  
【要消费的产品数量】:30   【库存量】:20    暂时不能执行生产任务!  
【已经生产产品数】:10    【现仓储量为】:30  
【要消费的产品数量】:50   【库存量】:30    暂时不能执行生产任务!  
【已经消费产品数】:20    【现仓储量为】:10  
【已经生产产品数】:10    【现仓储量为】:20  
【要消费的产品数量】:30   【库存量】:20    暂时不能执行生产任务!  
【已经生产产品数】:80    【现仓储量为】:100  
【要生产的产品数量】:10   【库存量】:100   暂时不能执行生产任务!  
【已经消费产品数】:50    【现仓储量为】:50  
【已经生产产品数】:10    【现仓储量为】:60  
【已经消费产品数】:30    【现仓储量为】:30  
【已经生产产品数】:10    【现仓储量为】:40  

阻塞队列实现

这里就是我们的重点部分了,就是使用阻塞队列实现生产者消费者模式。
根据第一部分对于阻塞队列的介绍,我们再次改写Storage类。

package com.vivi.myTest.synchronizedTest.produceAndConsume;

import java.util.concurrent.LinkedBlockingQueue;

/**
 * Created by vivit on 2017/10/16.
 */
public class StorageWithBlockingQueue {
    // 仓库最大存储量
    private final int MAX_SIZE = 100;

    // 仓库存储的载体
    private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(
            100);

    // 生产num个产品
    public void produce(int num)
    {
        // 如果仓库剩余容量为0  
        if (list.size() == MAX_SIZE)
        {
            System.out.println("【库存量】:" + MAX_SIZE + "/t暂时不能执行生产任务!");
        }

        // 生产条件满足情况下,生产num个产品
        for (int i = 1; i <= num; ++i)
        {
            try
            {
                // 放入产品,自动阻塞
                list.put(new Object());
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }

            System.out.println("【现仓储量为】:" + list.size());
        }
    }

    // 消费num个产品
    public void consume(int num)
    {
        // 如果仓库存储量不足
        if (list.size() == 0)
        {
            System.out.println("【库存量】:0/t暂时不能执行生产任务!");
        }

        // 消费条件满足情况下,消费num个产品
        for (int i = 1; i <= num; ++i)
        {
            try
            {
                // 消费产品,自动阻塞
                list.take();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }

        System.out.println("【现仓储量为】:" + list.size());
    }

    // set/get方法
    public LinkedBlockingQueue<Object> getList()
    {
        return list;
    }

    public void setList(LinkedBlockingQueue<Object> list)
    {
        this.list = list;
    }

    public int getMAX_SIZE()
    {
        return MAX_SIZE;
    }
}

打印输出:

【库存量】:0 暂时不能执行生产任务!  
【库存量】:0 暂时不能执行生产任务!  
【现仓储量为】:1  
【现仓储量为】:1  
【现仓储量为】:3  
【现仓储量为】:4  
【现仓储量为】:5  
【现仓储量为】:6  
【现仓储量为】:7  
【现仓储量为】:8  
【现仓储量为】:9  
【现仓储量为】:10  
【现仓储量为】:11  
【现仓储量为】:1  
.....

注:文中代码引用了MONKEY_D_MENG作者的演示代码生产者/消费者问题的多种Java实现方式

到这里,阻塞线程和生产者消费者模式就都讲清楚了,自己也难得系统复习一下多线程的基础知识。下一篇文章会力争把线程池讲清楚。
相对于最开始的两篇文章,生产者和消费者模式开始,才开始真正有实践意义,前面的基础知识只能让我们同时多写几个“Hello world”。
碎碎念几下,我觉得线程池中这个“池”的概念真的很重要很基础,基本是一个程序员的必知必会内容。我陪boss面试面别人的时候,线程池数据库连接池各种资源池基本是必问内容。我自己工作时也确实体会到了池子的重要性,希望下一个文章能把池子的概念和线程池梳理清楚。

附上版权声明:
原作者:Vi_error,博客地址:Vi_error.nextval
转载请保持署名和注明原地址**

java多线程-阻塞队列实现消费者生产者 一,Java中三种实现生产者消费者 1,使用wait()/notify()的方式 2,使用J.U.C下Condition的await()/signal()的方式实现 3,使用阻塞队列实现 注:这篇博文主要将使用阻塞队列实现,至于前面的两种可以看看我的另外一篇博客 二,什么是阻塞队列,阻塞队列的特性 1,一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。 2,Jav... 阅读详情

相关推荐

Icarus Verilog和GTKwave使用简析

本简要介绍Icarus Verilog和GTKwave的使用,使用iverilog(Icarus Verilog)编译仿真verilog而使用GTKWave查看仿真数据波形下载安装 基本使用 iverilog使用 GTKWave使用 iverilog常用选项 使用库 注意

husipeng86的专栏 1万+

生产者/消费者问题的多种Java实现方式

生产者/消费者问题的多种Java实现方式   实质上,很多后台服务程序并发控制的基本原理都可以归纳为生产者/消费者模式,而这是恰恰是在本科操作系统课堂上老师反复讲解,而我们却视而不见不以为然的。 生产者消费者问题是研究多线程程序时绕不开的经典问题之一,它描述是有一块缓冲区作为仓库,生产者可以将产品放入仓库,消费者则可以从仓库中取走产品。解决生产者/消费者问题的方法可分为两类:(1)采用某种机

kewb_2013的专栏 957

电力系统设计实战:如何用ETAP绘制一次接线图并优化供电方案

本文详细介绍了如何使用ETAP软件进行电力系统一次接线图的绘制与供电方案优化。从基础环境配置到主接线拓扑构建,再到典型接线方式的对比分析与智能优化,为工业与民用电力系统设计提供实用指南。通过ETAP的可靠性分析和动态仿真功能,帮助工程师选择最优供电方案,提升系统可靠性和运维效率。

weixin_29250573的博客 209

Java多线程案例——阻塞队列(生产者消费者模型)

阻塞队列(生产者消费者模型)

小小码农 1166

在时间轴上联动多张内表:ABAP 的 PROVIDE ... ENDPROVIDE 区间联动迭代实战

PROVIDE 是 ABAP 中处理有效期区间数据的强大工具,它能自动将多张内表按时间维度切片并联合处理。其核心功能包括:指定区间边界字段(BOUNDS),定义外部总区间(BETWEEN),并通过工作区和标志位(VALID)标识每张表在当前子区间是否生效。该语法特别适合 HR 信息类型等有效期数据,能避免手动处理区间重叠、排序和空档等问题。使用时需注意字段投影(FIELDS)限制、工作区只读原则,以及异常处理(如区间重叠或未排序)。典型应用场景包括员工调岗记录、价格有效期管理等需要时间轴联动的业务逻辑。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 1675

SCI论文发表很容易【5】:比较容易中的期刊

整理了一些经管方面比较容易中稿的期刊,可供大家参考

qq_25018077的博客 1681

【Java多线程案例】使用阻塞队列实现生产者消费者模型

本期讲解:阻塞队列之生产者消费者模型,模拟实现生产者消费者模型。

我的主页 3270

ISO21434 组织网络安全管理(二)

为了实现网络安全工程,该组织建立并维护网络安全治理和网络安全文化,包括网络安全意识管理、能力管理和持续改进。这涉及到指定针对本文档的目标进行独立审计的特定于组织的规则和过程。 为了支持网络安全工程,该组织实施了网络安全的管理系统,包括管理工具和应用质量管理系统。

qq_42357877的博客 1322

JavaEE——阻塞队列(生产者消费者模型)详解

阻塞队列是什么?阻塞队列到底有什么用呢?生产者消费者模型是什么?一文带你了解到底~生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题; 生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取;

xyk:的博客 1011

Captcha must be filled out,解决Kaggle新用户注册无法弹出验证提示的问题

Captcha must be filled out

weixin_46713695的博客 5万+

Android面试指南及参考答案

【摘要】LesPark招聘Android开发工程师,要求3年以上经验,负责客户端功能开发与优化。岗位需掌握Java、多线程、网络编程(TCP/UDP/HTTP)及性能调试工具。面试重点考察:1)核心技术如网络协议选择(TCP可靠消息/UDP实时音视频)、内存泄漏分析;2)业务能力如图片懒加载三级缓存设计、启动速度优化案例;3)高阶系统原理如插件化框架设计;4)行为问题应对策略。建议候选人准备并发编程、JVM差异等深度知识,并量化项目优化成果,尤其关注社交应用相关的图片处理、实时通信等场景题。

郑伟强dev的专栏 807

【Java|多线程与高并发】阻塞队列以及生产者-消费者模型

阻塞队列(BlockingQueue)常用于多线程编程中,可以实现线程之间的同步和协作。它可以用来解决生产者-消费者问题,其中生产者线程将元素插入队列,消费者线程从队列中获取元素,它们之间通过阻塞队列进行协调。阻塞队列的使用可以简化多线程编程的复杂性,避免手动实现线程间的同步和协作逻辑,提高代码的可读性和可维护性。基于阻塞队列的生产者-消费者模型也要重点掌握.。阻塞队列作为生产者和消费者之间的缓冲区,提供线程安全的插入和获取操作,并在队列为空或队列已满时进行阻塞,从而实现线程间的同步。

云泽野の编程日记 1982

【WRF-UCM】BEP+BEM 模拟:README

【WRF-UCM】BEP+BEM 模拟:README

WW、forever的博客 223

多线程-生产者和消费者模式的四种实现

什么是生产者和消费者模式: 生产者和消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此并不直接通信,而是通过阻塞队列进行通信,所以生产者生产完数据后不用等待消费者进行处理,而是直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列中获取数据,阻塞队列就相当于一个缓冲区,平衡生产者和消费者的处理能力。 wait/notify和synchronized配合实现: 生产者...

Fly_Fly_Zhang的博客 7204

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

初始JavaEE篇——多线程(5):生产者-消费者模型、阻塞队列

阻塞队列、生产者—消费者模型、模拟实现阻塞队列

我要学编程的博客 2018

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

多线程(初阶七:阻塞队列和生产者消费者模型)

首先,我们都知道,队列是先进先出的一种数据结构,而阻塞队列,是基于队列,做了一些扩展,在多线程有就非常有意义了阻塞队列的特性:(1)是线程安全的(2)具有阻塞的特性①当队列满了,这时不能往队列里放数据,就会阻塞等待,等队列的数据出队列后,这时队列没满,才能放数据。②当队列空了,这时不能拿队列里的数据,就会阻塞等待,等有数据如队列了,这时队列不为空,才能拿数据。这里,阻塞队列的用处非常大,基于阻塞队列的功能,就可以实现 “生产者消费者模型”。

cool_tao6的博客 3077

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

【多线程学习】深入探究阻塞队列与生产者消费者模型和线程池常见面试题

阻塞队列(BlockingQueue)是一种特殊的队列,在Java等编程语言中广泛应用于多线程同步与通信,它是一个线程安全的数据结构,主要用于在多线程环境下存储和传递数据。阻塞队列的关键特性在于,当队列处于特定状态时,对队列的插入(生产)或删除(消费)操作能够自动让线程进入等待状态。当队列为空时,执行从队列中获取元素(如调用take()方法)的线程会被阻塞,直到其他线程向队列中放入元素使其变为非空。当队列已满时,尝试向队列中添加元素(如调用put()

xiaoxie8023的博客 2773

生产者消费者模式三种实现方式

1.什么是生产者消费者模式: 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取,阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力。 这个阻塞队列就是用来给生产者和消费者解耦的。纵观大多数设计模式,都会找一个第三者出来进行解耦,如工厂模式的第三者是工厂类,模板模式的第三者是模板类。在学习一些设计模式的过程中,如果先找到

weixin_38568503的博客 1万+

【Java系列】多线程案例学习——基于阻塞队列实现生产者消费者模型

【Java系列】多线程案例学习——基于阻塞队列实现生产者消费者模型

m0_74352571的博客 2885

java实现生产者消费者模式

一: 什么是生产者消费者模型 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取,阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力。 简单来说: 生产者消费者模型就是指,在一个系统中,存在两种角色,一个为生产者,一个为消费者,通过一个缓冲区(仓库)进行通信,生产者将生产的产品放入仓库,消费...

向上的"狼"的博客 8208

设计模式:阻塞队列,生产者-消费者模型

这张图是生产者-消费者模型的基本示意图。生产者-消费者模式通过引入一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯,而是通过阻塞队列来进行通讯。生产者生产数据后直接将其放入阻塞队列中;消费者需求数据时直接从阻塞队列中取数据。阻塞队列相当于一个缓冲区,平衡了消费者与生产者之间的处理能力阻塞队列使得生产者与消费者解耦解耦(Decoupling)是指在系统设计中,将不同组件、模块或子系统之间的依赖关系降低,使它们能够独立运作和变化。

dalaoyuzuiniu的博客 1454

Java【多线程】(4)阻塞队列

哈喽大家好吖,今天来给大家分享多线程学习中的阻塞队列,阻塞队列在我们开发中也是一个非常重要的内容,那么话不多说让我们开始吧。

2301_81073317的博客 3520

Java 入门指南:Java 并发编程模式 —— 生产者-消费者模式

生产者/消费者模式是一种重要的多线程设计模式,它通过引入共享队列来实现生产者和消费者之间的解耦。这种模式不仅可以提高系统的并发性和灵活性,还可以平滑负载,适用于多种应用场景。通过使用阻塞队列、wait/notify 机制或者 Exchanger,可以方便地实现生产者/消费者模式,并解决多线程环境下数据生产和消费的问题。

热带鱼的技术博客 1925

【操作系统】阻塞队列以及生产者消费者模型

阻塞队列就相当于⼀个缓冲区,平衡了生产者和消费者的处理能⼒.(削峰填⾕)阻塞队列也能使生产者和消费者之间解耦.

smile_sundays的博客 1241

【多线程初阶】阻塞队列 & 生产者消费者模型

比如在"秒杀"场景下,服务器同一时刻可能会收到大量的支付请求,如果直接处理这些支付请求,服务器可能扛不住(每个支付请求处理都需要比较复杂的流程),这个时候就可以把这些请求都放到一个阻塞队列中,然后再由消费者线程慢慢的按照自己的节奏来处理每个支付请求,不至于下游服务器直接崩溃。像 B这种下游的服务器,同行承担更重的任务量,复杂的计算/存储 工作,单个请求消耗的资源数更多。一般来说 A这种上游的服务器,尤其是 入口的服务器,干的活更简单,单个请求消耗的资源数少。包括不限于 CPU,内存,硬盘,网络带宽的资源。

2503_90322569的博客 1401

什么是阻塞队列? 如何使用阻塞队列来实现生产者-消费者模型?

什么是阻塞队列? 阻塞队列是一个在队列基础上又支持了两个附加操作的队列。 2个附加操作: 支持阻塞的插入方法:队列满时,队列会阻塞插入元素的线程,直到队列不满。 支持阻塞的移除方法:队列空时,获取元素的线程会等待队列变为非空。 阻塞队列的应用场景 阻塞队列常用于生产者和消费者的场景,生产者是向队列里添加元素的线程,消费者是从队列里取元素的线程。简而言之,阻塞队列是生产者用来存放元素...

架构师专栏 9879
上一篇: 从零学习JAVA多线程(三):线程的同步问题
下一篇: captcha和recapcha
Vi_error
博客等级 码龄13年 10粉丝 34原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值