阻塞式队列——生产者消费者模型

最新推荐文章于 2022-03-08 18:19:57 发布
最新推荐文章于 2022-03-08 18:19:57 发布
阅读量253 收藏
点赞数
分类专栏： 线程与进程 文章标签： 队列 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51529857/article/details/119573789
版权

文章目录

前言

生产者，消费者模型无论是平常开发中，还是面试中都是很经常用到的，它是通过一个容器来解决生产者和消费者的强耦合问题，生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不同等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里获取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力，这个阻塞队列就是用来给生产者和消费者解耦的

一、阻塞队列

  1. 阻塞队列就如同队列，先进先出
  2. 阻塞：表示这个队列是线程安全的
  3. 当队列满的时候往里面插入元素，此时会阻塞，一直阻塞到队列不满的时候才会完成插入
  4. 当对列为空的时候，从队列中取元素，此时也会阻塞，一直到队列不为空时，才能完成去元素操作

下面来康康代码如何实现的吧

public static void main(String[] args) throws InterruptedException {
        BlockingDeque<String> deque = new LinkedBlockingDeque<>(3);
        deque.put("a");
        deque.put("b");
        deque.put("c");
        //它的初始容量只有3，当我们放进去第四个的时候会出现什么样的效果？
        deque.put("d");
    }


}

结果就是一直处于阻塞状态直到可以放了
在这里插入图片描述


 public static void main(String[] args) throws InterruptedException {
        BlockingDeque<String> deque = new LinkedBlockingDeque<>(3);
        deque.put("a");
        deque.put("b");
        deque.put("c");
        //它的初始容量只有3，当我们放进去第四个的时候会出现什么样的效果？
     //   deque.put("d");
        System.out.println(deque.take());
        System.out.println(deque.take());
        System.out.println(deque.take());
        System.out.println(deque.take());
       // System.out.println(deque.take());

    }


}

同样的当我们只有三个，想要取更多的时候就会发生阻塞
在这里插入图片描述

传统的生产者、消费者问题

/**
 * A B操作同一变量，num
 * A+1，B-1  保证AB之间通信
 */
public class A {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
    }

}

class Data {
    private int num = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if (num != 0) {
            //等待

            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + "->" + num);
        //通知其他线程
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if (num == 0) {
            //等待
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "->" + num);
        //通知
        this.notifyAll();
    }
}
  • 如果多个线程 A B C D
public static void main(String[] args) {
    Data data = new Data();
    new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            try {
                data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "A").start();

    new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            try {
                data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "B").start();
    new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            try {
                data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "C").start();
    new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            try {
                data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "D").start();
}
}


class Data {
    private int num = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        if (num != 0) {
            //等待

            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + "->" + num);
        //通知其他线程
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        if (num == 0) {
            //等待
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "->" + num);
        //通知
        this.notifyAll();
    }
}

出现了异常情况
在这里插入图片描述

  • 防止虚假唤醒 :线程可以被唤醒，而不会接到通知，中断或超时
  • 等待总是出现在循环中，上面用if判断可能会造成虚假唤醒 下面是防止虚假唤醒的
public static void main(String[] args) {
    Data data = new Data();
    new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            try {
                data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "A").start();

    new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            try {
                data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "B").start();
    new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            try {
                data.increment();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "C").start();
    new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            try {
                data.decrement();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }, "D").start();
}
}


class Data {
    private int num = 0;

    //+1
    public synchronized void increment() throws InterruptedException {
        while (num != 0) {
            //等待

            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + "->" + num);
        //通知其他线程
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        while (num == 0) {
            //等待
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "->" + num);
        //通知
        this.notifyAll();
    }
}

JUC版的生产者消费者问题

public class B {
    public static void main(String[] args) {
        Data2 data = new Data2();
        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();

        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();

        new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "D").start();
    }
}


class Data2 {
    private int num = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    //+1
    public  void increment() throws InterruptedException {
        lock.lock();
        try {
            while (num != 0) {//0
                //等待
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName() + "->" + num);
            //通知其他线程
            condition.signalAll();
        }catch (Exception e ){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (num == 0) {//1
                //等待
                condition.await();
            }
                num--;
                System.out.println(Thread.currentThread().getName() + "->" + num);
                //通知
                condition.signalAll();
        }catch (Exception e ){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

-上面代码使用lock 中的await()和signalAll() 来实现线程之间相互通信
-但是还有个问题 这个代码每次运行结果都不一样，我们怎么能让A执行完执行B，B执行完执行C呢,那么就要用到精准通知signal()

/**
 * A->B->C  A执行完调用B  B执行完调用C  C执行完调用A 精准通知唤醒
 */
public class C {
    public static void main(String[] args) {
        Data3 data3 = new Data3();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                data3.PrintA();
            }
        },"A").start();
        new Thread(()->{ for (int i = 0; i <10 ; i++) {
            data3.PrintB();
        }},"B").start();
        new Thread(()->{ for (int i = 0; i <10 ; i++) {
            data3.PrintC();
        }},"C").start();
    }
}
class Data3{
    private Lock lock = new ReentrantLock();
   private Condition condition1 = lock.newCondition();
   private  Condition condition2 = lock.newCondition();
   private  Condition condition3 = lock.newCondition();
   private  int  num =1; //1时A执行  2时B执行  3时C执行
    public void PrintA(){
       lock.lock();
       try{
           while (num!=1){
               condition1.await();
           }
           System.out.println(Thread.currentThread().getName()+"----A");
           //唤醒B
           condition2.signal();
           num=2;
       }catch (Exception e){
           e.printStackTrace();
       }finally {
           lock.unlock();
       }

    }
    public void PrintB(){
    lock.lock();
    try {
        while (num!=2){
            condition2.await();
        }
        System.out.println(Thread.currentThread().getName()+"----B");
        num=3;
        condition3.signal();

    }catch (Exception e){
        e.printStackTrace();
    }finally {
        lock.unlock();
    }
    }
    public void PrintC(){
        lock.lock();
        try {
            while (num!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"----C");
            num=1;
            condition1.signal();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

总结

注意BlockingQueue有四组API，如下图，每一种方法都有不同的用处，注意多写代码体会其中的差别，以及使用场景
在这里插入图片描述
关于生产者和消费者问题，包括里面涉及到的虚假唤醒，以及精准通知其实都很简单，动手写写就明白了

·_int
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
阻塞队列与生产者消费者模型
qq_45726327的博客
03-31 228
前面我们介绍了,notify和wait方法的说明,这里我们会引入一个综合的应用,对这个notify方法和wait方法的使用,让大家进一步了解阻塞队列,顺便了解完阻塞队列以后,我们会学习阻塞队列的一个应用消费者和生产者模式.大家尽请期待.实际上阻塞队列，就是起到一个阻塞等待的觉结果，其实它就是一个特殊的队列，它遵循一个先进先出的原则。我来列举一下阻塞队列的俩个特性:1.当队列满的时候，继续入队列就会阻塞等待，直到有其他线程从队列中取走元素。
【Linux】多线程同步--基于阻塞队列的生产者消费者模型（条件变量解决）
呋喃吖的博客
05-20 553
文章目录线程同步条件变量条件变量相关接口生产者消费者模型基本理论基于阻塞队列的生产者消费者模型 线程同步 什么是线程同步？ 首先先了解一下：互斥锁带来的一个问题：就是线程饥饿现象：就是多个线程长时间访问不到共享资源，不得已使得线程的执行流得以推进执行，这种现象就是线程饥饿现象！ 有线程饥饿线程的原因就是互斥锁带来的问题！ 有一种场景是，当一个线程A获得锁时候，进入临界区，访问结束后，释放锁，该线程A大概率的竞争能力比其他线程更加强，有可能重新获得锁，再次访问临界区！而其他线程可能竞争力不够强，长时间无法获
生产者/消费者模式(阻塞队列)
canofy
06-19 193
生产消费者模式 貌似也是阻塞的问题 花了一些时间终于弄明白这个鸟东东，以前还以为是不复杂的一个东西的，以前一直以为和观察者模式差不多(其实也是差不多的，呵呵)，生产消费者模式应该是可以通过观察者模式来实现的，对于在什么环境下使用现在想的还不是特别清楚，主要是在实际中还没使用过这个。 需要使用到同步，以及线程，属于多并发行列，和观察者模式的差异也就在于此吧，所以实现起来也主要在这里...
什么是阻塞队列？如何使用阻塞队列来实现生产者-消费者模型？
weixin_34248023的博客
03-14 578
什么是阻塞队列？ 阻塞队列是一个在队列基础上又支持了两个附加操作的队列。 2个附加操作： 支持阻塞的插入方法：队列满时，队列会阻塞插入元素的线程，直到队列不满。 支持阻塞的移除方法：队列空时，获取元素的线程会等待队列变为非空。 阻塞队列的应用场景 阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的...
什么是阻塞队列？阻塞队列的实现原理是什么？如何使用阻塞队列来实现生产者-消费者模型？
欢迎光临雨落星辰的博客
03-08 393
阻塞队列是一个在队列基础上又支持了两个附加操作的队列。 2个附加操作： 支持阻塞的插入方法：队列满时，队列会阻塞插入元素的线程，直到队列不满。 支持阻塞的移除方法：队列空时，获取元素的线程会等待队列变为非空。 阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的线程。简而言之，阻塞队列是生产者用来存放元素、消费者获取元素的容器。 ArrayBlockingQueue 一个由数据结构组成的有界阻塞队列 LinkedBlockingQueue 一
操作系统生产者消费者问题
09-08
操作系统中的“生产者消费者问题”是一个经典的多线程同步问题，它模拟了两个不同角色——生产者和消费者——在共享资源中的协作。在这个问题中，生产者负责创建产品并放入缓冲区，而消费者则从缓冲区取出产品进行...
生产者消费者为模型的多线程编程c#原创
09-17
在C#编程中，"生产者消费者模型"是一种常见的多线程设计模式，它通过分离数据的生产和消费过程，使得生产者线程可以专心于创建数据，而消费者线程则专注于处理这些数据，两者互不干扰，提高了系统效率。在这个模型中...
生产者消费者
01-06
生产者消费者模式是一种多线程同步问题的经典解决方案，它源于现实世界中的生产流水线，用于描述两种类型的参与者——生产者和消费者——如何有效地共享有限的资源。在这个模式中，生产者负责创建产品，而消费者则...
java多线程实现生产者消费者关系
11-07
在实际应用中，我们常常会遇到一种典型的多线程问题——生产者消费者模型。这个模型描述了两种类型的线程：生产者线程负责创建或生产资源，而消费者线程则负责消耗这些资源。在Java中，我们可以利用同步机制来实现...
java 编写的生产者与消费者问题
04-08
该问题描述了两个并发执行的进程——生产者和消费者，它们共享一个有限大小的缓冲区。生产者进程负责生成数据（消息）并放入缓冲区，而消费者进程则负责从缓冲区取出并处理这些数据。这个问题的核心挑战在于如何协调...
Python的队列deque和Queue模块
weixin_41278695的博客
04-15 2157
最近在python3刷题的时候，常用到deque模块，以前对其不太了解，现在特此转载记录一下（侵权删） deque模块是python标准库collections中的一项，它提供了两端都可以操作的序列，这意味着，在序列的前后你都可以执行添加或删除操作。 1.创建deque序列： from collections import deque d=deque() 2.deque提供了类似list...
进程同步之生产者消费者模型
HiMark
08-17 8719
一、概念引入 例如寄信 我（生产者） 邮递员（消费者） 我把信件写好 -----相当于生产者生产数据 我把信放到邮筒-----相当于把生产者的数据放入到缓冲区 邮递员把信从邮筒取出-----相当于消费者把数据从缓冲区取出 邮递员把信拿去邮局处理------相当于消费者处理数据 ...
java生产者消费者 阻塞_Java设计模式—生产者消费者模式（阻塞队列实现）
weixin_42113552的博客
02-13 114
生产者消费者模式是并发、多线程编程中经典的设计模式，生产者和消费者通过分离的执行工作解耦，简化了开发模式，生产者和消费者可以以不同的速度生产和消费数据。这篇文章我们来看看什么是生产者消费者模式，这个问题也是多线程面试题中经常被提及的。如何使用阻塞队列(Blocking Queue)解决生产者消费者模式，以及使用生产者消费者模式的好处。真实世界中的生产者消费者模式生产者和消费者模式在生活当中随处可见...
java生产者消费者 阻塞_java之使用阻塞队列实现生产者，消费者模式
weixin_32956805的博客
02-13 217
在看代码之前,笔者先说几句题外话，生产者-消费者模式，一直是多线程编程中的经典设计模式，不仅仅提现在Java中，各个类C语言，以及其他的一些高级语言中都有实现，在Java 5之前，还没有出现阻塞队列的容器时，实现一个生产者消费者模式，相对来说比较复杂，代码量也比较大，最重要的是设计同步存取时更需要小心谨慎，一不小心就会带来莫名其妙的问题。Java 5之前实现同步存取时，可以使用普通的一个集合，然后...
阻塞队列实现生产者消费者模型
an_gentle_killer的博客
09-12 225
基于阻塞队列实现生产者消费者模型（极简版） 学过了wait-notify机制的生产者消费者模型（传送门：wait-notify机制生消模型） 再来看看基于阻塞队列BlockingQueue的生产者消费者模型 /** * 概述： * 总共能生产100次，消费100次 * 但是队列中的存在的数量最多有10个 * 注意： * 标记一：为了直观的看到队列满了，需要消费了，但是队列自己会阻塞我们无需进行通知 * 标记二：也是为了直观的看到队列在阻塞 */ public class Test {
生产者与消费者模型----阻塞队列
childemao的博客
04-06 310
生产者与消费者模型 生产者与消费者模型：一种设计模式—大佬们针对典型场景设计的解决方案。 生产者生产的数据放入队列中，消费者取数据从队列中取。 阻塞队列： 1、生产者与消费者模型所解决的问题：解耦和，支持并发，支持忙闲不均。（优点） 1、解耦和 假设生产者和消费者分别是两个类：如果让生产者直接调用消费者的某个方法，那么生产者对于消费者就会产生依赖（也就是耦合）。将来如果消费者的代码发生变化，...
阻塞队列实现生产者消费者模式
男儿当自强
07-09 711
用阻塞队列实现生产者消费者模式
PV操作——生产者消费者问题
最新发布
05-31
生产者消费者问题是一个经典的同步问题，其中包含两种进程类型：生产者和消费者。生产者进程负责生产一些数据，并将其放入共享缓冲区中，而消费者进程则从共享缓冲区中取出数据并进行消费。这两种进程必须协调进行，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值