八、生产者-消费者模型

最新推荐文章于 2024-07-23 10:19:57 发布
最新推荐文章于 2024-07-23 10:19:57 发布
阅读量87 收藏
点赞数
分类专栏： JUC 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu1308156206/article/details/125688768
版权

一、synchronized实现

  1. synchronized实现生产者-消费者模型

    /**
 * 生成者消费者例子
 * 两个线程：生产线程生产数据 消费线程消费数据
 * 如果当前有数据，生产者线程等待
 * 如果当前没数据，消费者线程等待
 */
public class ProdConsumDemo {
    public static void main(String[] args) {
        Data data = new Data();

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

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

class Data{
    private int num = 0;        //  0表示无数据 1表示有数据

    public synchronized void produceData() throws InterruptedException {
        if(num != 0){
            //有数据
            //生产者线程等待
            this.wait();     //会释放锁
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"线程:=>" + num);
        this.notifyAll();           //唤醒其他所有线程 wait中的线程
    }

    public synchronized void consumData() throws InterruptedException {
        if(num == 0){
            //没有数据
            //消费者线程等待
            this.wait();  //会释放锁
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"线程:=>" + num);
        this.notifyAll();           //唤醒其他所有线程 wait中的线程
    }
}

    上述代码 如果使用两个生产者 两个消费者 就会出现虚假唤醒问题。

    三个关键点：synchronized、wait、notify。

  2. 线程虚假唤醒问题

    按照官方文档上的说明。Object类中 wait方法的说明

在这里插入图片描述

把if判断改为while循环判断。

while(num != 0){
    //有数据
    //生产者线程等待
    this.wait();
}

while(num == 0){
    //没有数据
    //消费者线程等待
    this.wait();
}

二、Lock实现

  1. Lock实现生产者-消费者模型

    参考API说明

在这里插入图片描述

代码实现：

/**
 * 生成者消费者例子 Lock实现
 * 两组线程：生产线程生产数据 消费线程消费数据
 * 如果当前有数据，生产者线程等待
 * 如果当前没数据，消费者线程等待
 */
public class ProdConsumDemoLock {
    public static void main(String[] args) {
        Data2 data = new Data2();

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

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

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

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

class Data2{
    private int num = 0;        //  0表示无数据 1表示有数据

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    public  void produceData() throws InterruptedException {
        lock.lock();
        try {
            //使用while循环 防止虚假唤醒问题
            while (num != 0) {
                //有数据
                //生产者线程等待
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName() + "线程:=>" + num);
            //唤醒其他所有线程
            condition.signalAll();
        }
        catch (Exception e){}
        finally {
            lock.unlock();
        }
    }

    public  void consumData() throws InterruptedException {
        lock.lock();
        try{
            //使用while循环 防止虚假唤醒问题
            while(num == 0){
                //没有数据
                //消费者线程等待
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName()+"线程:=>" + num);
            //唤醒其他所有线程
            condition.signalAll();
        }
        catch (Exception e){}
        finally {
            lock.unlock();
        }

    }
}

上面代码随机输出。

Lock实现3要素: lock、await、signalAll。

三、Condition实现3条线程顺序执行

  1. 使用Condition的精准通知实现

  2. 代码实现

    /**
 * 通过Condition的线程精准唤醒
 * 实现3条线程循环执行
 * A->B->C->A->B...
 */
public class ConditionDemo {
    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 conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    private Condition conditionC = lock.newCondition();

    private int num = 1;

    public void printA(){
        lock.lock();
        try {
            while(num != 1)
                conditionA.await();         //线程A等待
            System.out.println(Thread.currentThread().getName()+"->AAAAAA");
            num = 2;
            //唤醒线程B
            conditionB.signal();
        }
        catch (Exception e){}
        finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try {
            while(num != 2)
                conditionB.await();         //线程B等待
            System.out.println(Thread.currentThread().getName()+"->BBBBBB");
            num = 3;
            //唤醒线程C
            conditionC.signal();
        }
        catch (Exception e){}
        finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();
        try {
            while(num != 3)
                conditionC.await();         //线程A等待
            System.out.println(Thread.currentThread().getName()+"->CCCCCC");
            num = 1;
            //唤醒线程A
            conditionA.signal();
        }
        catch (Exception e){}
        finally {
            lock.unlock();
        }
    }
}
wu1308156206
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
生产者-消费者模型
聂建jian的专栏
04-26 631
生产者-消费者模型 文章来自https://github.com/NieJianJian/AndroidNotes，内容将持续更新，欢迎star。 一. 前言 生产者消费者模式并不是GOF提出的23种设计模式之一，23种设计模式都是建立在面向对象的基础之上的，但其实面向过程的编程中也有很多高效的编程模式，生产者消费者模式便是其中之一，它是我们编程过程中最常用的一种设计模式。 面向过程就是分析出解...
生产者－消费者模型
rannianzhixia的博客
06-13 412
一、生产者－消费者模型是指： 1．  生产者进行生产将物品放入仓库，同一时间只能有一个生产者将物品放入仓库，如果仓库满，生产者等待。 2．  消费者从仓库中取出物品，同一时间只能有一个消费者取出物品，如果仓库空，消费者等待； 3．  生产者将物品放入仓库时消费者不能同时取； 4．  消费者取物品时生产者不能放入物品； 二、生产者/消费者模型的优点 1、解耦，即降低生产者和消费者之间
生产者消费者模型
rfgyytr的博客
09-18 186
“生产者-消费者”问题又被称作“有界缓冲区”问题，即至少一个生产者与至少一个消费者针对一个公用的初始大小固定的缓冲区进行操作。            生产者和消费者之间用中间类似一个队列（缓冲区）一样的东西串起来。这个队列可以想像成一个存放产品的“仓库”，生产者用于将消息放入缓冲区中，它只需要关心这个“仓库”，并不需要关心具体的消费者，对于生产者而言甚至都不知道有这些消费者存在。消费者用于从缓冲
【生产-消费模型】生产者 - 消费者模型原理及实现
最新发布
qq_38089448的博客
07-23 1082
假设有两个进程（或线程）A、B和一个固定大小的缓冲区，A进程生产数据放入缓冲区，B进程从缓冲区中取出数据进行计算，这就是一个简单的生产者-消费者模型。这里的A进程相当于生产者，B进程相当于消费者。
jchc.rar_tearshmj_生产者_生产者-消费者问题 c++ _生产者和消费者_生产者消费者
09-23
首先，我们要理解生产者-消费者模型的基本概念。在这个模型中，生产者负责生产资源，而消费者则负责消耗这些资源。关键在于，生产者和消费者必须以一种协调的方式工作，以免出现资源过度消费或生产过剩的情况。这就...
操作系统之Linux下的生产者－消费者模型
03-03
结合System　V信号量机制，利用Linux下的多线程库实现了Linux下的操作系统生产者－消费者模型，具体原理可参考博文：：　http://blog.csdn.net/Mikeoperfect/article/details/79431642
生产者-消费者模型模拟进程调度
11-05
内含多个实验文档与可运行的代码 ...1. 生产者消费者对缓冲区进行互斥操作。 2. 缓冲区大小为10，缓冲区满则不允许生产者生产数据，缓冲区空则不允许消费者消费数据。 3. 生产者消费者各循环操作10次。
linux进程链、进程扇和信号量实现生产者--消费者模型实验报告
12-26
通过对生产者-消费者模型的实现，学生将学习如何在Linux环境下运用无名信号量来保护临界资源，同时提升对文件I/O操作的掌握。 二、实验内容 实验分为三个部分： 1. 使用链式结构创建10个子进程，形成进程链。 2. ...
理解生产者消费者模型及在Python编程中的运用实例
12-25
什么是生产者消费者模型 在 工作中，大家可能会碰到这样一种情况：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产 生数据的模块，就形象地称为...
Windows环境下的生产者-消费者模型：信号量实现
"操作系统实验二的核心内容是实现生产者-消费者模型，利用信号量机制解决同步和互斥问题。在Windows环境下，通过C++编写控制台程序或界面程序，创建多线程，模拟生产者线程和消费者线程。生产者负责写入数据到缓冲区...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值