线程间通信——生产者和消费者模式

最新推荐文章于 2022-08-24 20:18:15 发布
最新推荐文章于 2022-08-24 20:18:15 发布
阅读量278 收藏
点赞数
分类专栏： JAVA Basics 文章标签： java 线程通信 多线程 生产者和消费者模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45337431/article/details/99283493
版权

消费者和生产者模式

是用来描述一个仓库(缓冲区)，生产者可以将产品放入到仓库中,消费者可以从仓库中买走商品,解决生产者和消费者的生活逻辑问题,需要采用代码的同步机制来完成相互的【约束】和【提醒】。

注意事项

  1. 【商品是唯一共享资源】
  2. 消费者购买商品，清空商品的库存，要【提醒】生产者生产，并且消费者停止购买
  3. 生产者生产商品，填满商品的库存，要【提醒】消费者购买(到货通知)，并且生产者是要停止生产操作

在这里插入图片描述

实现方法

采用wait()、notify()和notifyAll()方法。

wait()：当缓冲区已满或空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等待状态，让其他线程执行

  • 是Object的方法
  • 调用方式：对象.wait();
  • 表示释放 对象 这个锁标记，然后在锁外边等待（对比sleep(),sleep是抱着锁休眠的）
  • 等待，必须放到同步代码段中执行

notify()：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态

  • 是Object的方法
  • 调用方式：对象.notify();
  • 表示唤醒 对象 所标记外边在等待的一个线程，或者从多个待唤醒线程中随机唤醒一个

notifyAll():全部唤醒

  • 是Object的方法
  • 调用方式：对象.notifyAll()
  • 表示唤醒 对象 所标记外边等待的所有线程

案例

生产者生产面包，消费者消费面包，要求仓库有面包时，提醒消费者消费，生产者出于等待状态；当没有面包的时候，提醒生产者生产，消费者处于等待。即生产一件，消费一件。
基本思路：

  1. 创建面包类，构建相关的属性和方法。
  2. 创建面包仓库类，面包类对象传入，并创建sychronized修饰的同步方法——input和output方法。
  3. 创建两个线程，生产者product和消费者consumer，分别继承Runnable，重写run()方法，并分别调用input和output方法，保证同步。
  4. 在主方法创建Thread，并start。
/**
* 面包类
*/
public class Bread {
    private int id;
    private String productName;

    public Bread() {
    }
    public Bread(int id, String productName) {
        this.id = id;
        this.productName = productName;
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }
}

/**
* 面包容器类
*/
public class BreadCon {
    private Bread con;
    private boolean flag = false;   //判断仓库是否有面包，false表示没有

    public synchronized void input(Bread b) throws InterruptedException {
        if (flag) {
            this.wait();	//如果仓库有面包，则处于阻塞状态，等待消费者消费后唤醒
        }
        this.con = b;
        System.out.println(Thread.currentThread().getName() + "生产了" 
        + b.getId() + "号面包");
        flag = true;
        this.notify();	//仓库没有面包，则生产面包，并将标记改为true，唤醒消费者购买
    }

    public synchronized void output() throws InterruptedException {
        if (!flag) {
            this.wait();
        }
        Bread b= con;  
        con = null;
        System.out.println(Thread.currentThread().getName()+"消费了"
        +b.getId() + "号面包" +" 生产者:"+b.getProductName());
        flag = false;	//修改标记
        this.notify();	//唤醒生产者生产
    }
}

/**
* 生产者类
*/
public class Product implements Runnable{
    private BreadCon con;
    public Product(BreadCon con) {
        this.con = con;
    }
    @Override
    public void run() {
        for (int i = 1; i <= 30; i++) {
            Bread b = new Bread(i, Thread.currentThread().getName());
            try {
                this.con.input(b);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
* 消费者类
*/
public class Consumer implements Runnable {
    private BreadCon con;
    public Consumer(BreadCon con) {
        this.con = con;
    }
    @Override
    public void run() {
        for (int i = 1; i <= 30; i++) {
            try {
                con.output();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
* 测试类
*/
public class test {
    public static void main(String[] args) {
        //创建容器
        BreadCon con = new BreadCon();
        //生产
        Product product = new Product(con);
        //消费
        Consumer consumer = new Consumer(con);
        //线程对象启动
        new Thread(product, "面包生产商A").start();
        new Thread(consumer, "消费者1").start();
    }
}

//打印结果
面包生产商A生产了1号面包
消费者1消费了1号面包 生产者:面包生产商A
面包生产商A生产了2号面包
消费者1消费了2号面包 生产者:面包生产商A
面包生产商A生产了3号面包
消费者1消费了3号面包 生产者:面包生产商A
面包生产商A生产了4号面包
消费者1消费了4号面包 生产者:面包生产商A
面包生产商A生产了5号面包

思考：如果生产方不止一个，消费方也不止一个，如何设计？

我们分别为生产者和消费者创建两个线程，运行结果如下：

new Thread(product, "面包生产商A").start();
new Thread(product, "面包生产商B").start();
new Thread(consumer, "消费者1").start();
new Thread(consumer, "消费者2").start();

//打印结果
//不止运行结果异常，而且还发生了死锁
面包生产商A生产了1号面包
消费者1消费了1号面包 生产者:面包生产商A
消费者2消费了1号面包 生产者:面包生产商A
面包生产商A生产了2号面包
消费者1消费了2号面包 生产者:面包生产商A
消费者2消费了2号面包 生产者:面包生产商A

为何会发生错误和死锁？

  1. 生产商A抢到CPU，执行生产面包，修改标记为true
  2. 生产商A抢到CPU，但是标记为true，等待，释放CPU和锁
  3. 生产商B抢到CPU，但是标记为true，等待，释放CPU和锁
  4. 消费者1抢到CPU，执行消费面包，修改标记为false，唤醒生产商A
  5. 生产商A抢到CPU，执行生产面包，修改标记为true，唤醒生产商B（notify随机唤醒一个）
  6. 生产商B抢到CPU，但是标记为true，等待，释放CPU和锁
  7. 生产商A抢到CPU，但是标记为true，等待，释放CPU和锁
  8. 消费者1抢到CPU，执行消费面包，修改标记为false，唤醒消费者2（notify随机唤醒一个）
  9. 消费者2抢到CPU，但是标记为false，等待，释放CPU和锁
  10. 消费者1抢到CPU，但是标记为false，等待，释放CPU和锁

最终四者全部处于阻塞状态，都在等待唤醒，发生死锁。

另外，当处于阻塞状态的线程被唤醒的时候，会继续执行后面代码。在第2、3步，A与B都被阻塞，在第4步，A被唤醒后，会继续执行后面生产面包的代码，然后在第5步，又抢到时间片，又会执行生产面包的代码，然后notify还唤醒了另一个生产商B，B会继续执行后面的生产面包代码，这样会出现多生产2次面包的情况，即错误状态。

解决办法：

  • 将 if 判断语句改为 while 循环判断语句，保证被唤醒后，不再继续执行生产面包代码，而是返回进行循环判断判断
  • 将 notify 改为 notifyAll ，避免发生死锁情况。
//这里只针对面包容器类进行修改
public class BreadCon {
    private Bread con;
    private boolean flag = false;   //判断仓库是否有面包，false表示没有

    public synchronized void input(Bread b) throws InterruptedException {
        while (flag) {
            this.wait();
        }
        this.con = b;
        System.out.println(Thread.currentThread().getName() + "生产了" + b.getId()
         + "号面包");
        flag = true;
        this.notifyAll();
    }
    public synchronized void output() throws InterruptedException {
        while (!flag) {
            this.wait();
        }

        /*Bread b= con;
        con = null;*/
        System.out.println(Thread.currentThread().getName()+"消费了"+con.getId() 
        + "号面包" +" 生产者:"+con.getProductName());
        flag = false;
        this.notifyAll();
    }
}

//打印结果
面包生产商A生产了1号面包
消费者1消费了1号面包 生产者:面包生产商A
面包生产商B生产了1号面包
消费者2消费了1号面包 生产者:面包生产商B
面包生产商A生产了2号面包
消费者1消费了2号面包 生产者:面包生产商A
面包生产商B生产了2号面包
消费者2消费了2号面包 生产者:面包生产商B

效率问题
虽然解决了错误和死锁问题，但如果生产者和消费者数量及其庞大，每次notifyAll会将无关的线程也唤醒，增加了无效的判断时间，效率大打折扣，所以这里采用Condition接口，配合Lock接口下的ReentrantLock实现类解决效率问题。

Condition接口

sychronized的锁方式，只能让生产者和消费者进入同一个阻塞队列，所以notifyAll会将队列中所有线程唤醒。

Condition接口则提供了两个队列，一个消费队列，一个生产队列，进行锁的微操，甚至可以自定义提供三个甚至更多队列，实现多线程的同步，并保证效率。

方法的使用

//创建Lock对象
Lock lock = new ReentrantLock();

//根据需求创建自定义数量的Condition条件队列
Condition condition = lock.newCondition();

//使某一队列等待，相当于wait()
condition.await();

//使某一队列唤醒，相当于notify()
condition.signal(); 
//

案例一：面包案例优化

这次我们将面包放到一个数组进行生产，当数组满了以后可以提醒消费者购买，所以也会在没满的时候，消费者也会购买，模拟实际的生产和消费模式。

//这里只提供核心代码块
public class BreadCon {
    /*这里必须用-1，否则出现索引越界异常，因为后面消费者消费index--会出现index=-1的情况
     *为了避免因为生产者生产的时候breads[index]调取异常
     *会将index++放到赋值之前，保证索引从0开始
     */
    private int index = -1;
    private Bread[] breads = new Bread[5];

    //创建ReentrantLock锁对象，并创建两个阻塞队列，一个是生产者proCon，一个是消费者conCon
    private Lock lock = new ReentrantLock();
    private Condition proCon = lock.newCondition();
    private Condition conCon = lock.newCondition();

    public BreadCon() {
    }

    public void input(Bread bread) {
        lock.lock();    //上锁

        try {
            while (index > 3) {
                proCon.await(); //如果面包数量超过数组容量，则生产者处于生产阻塞队列
            }
            index++;    //因为Index是从-1开始，所以放到赋值之前，从0开始索引
            breads[index] = bread;
            System.out.println("生产者：" + Thread.currentThread().getName() 
            + "生产了" + bread.getId() + "号面包");
            conCon.signal();    //如果有面包，则将消费队列消费者唤醒
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock(); //解锁
        }
    }

    public void output()  {
        lock.lock();

        try {
            while (index < 0) {
                try {
                    conCon.await();     //如果没有面包，则将消费者置于消费阻塞队列
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Bread b = breads[index];
            breads[index] = null;
            System.out.println("消费者：" + Thread.currentThread().getName() 
            + "消费了" + b.getId() + "号面包，生产者是：" + b.getProductName());
            index--;
            proCon.signal();        //每消费一次面包，可以唤醒生产者生产
        } finally {
            lock.unlock();
        }
    }
}

案例二：三个线程交替输出A B C ，输出20遍

这里需要构筑三个Condition队列锁。

public class PrintABC {
    private int flag = 1;   //1表示A, 2表示B, 3表示C
    private Lock lock = new ReentrantLock();
    private Condition aCon = lock.newCondition();
    private Condition bCon = lock.newCondition();
    private Condition cCon = lock.newCondition();

    public void printA() {
        lock.lock();
        try {
            while (1 != flag) {
            	//这里注意，必须将阻塞放到循环判断中
            	//这样最后一次循环的时候，A被唤醒，可以继续执行下面的代码，依次唤醒BC，线程退出
            	//否则，如果将后面代码放到判断里，将里面的阻塞放到外面，则A被唤醒，却不能调用signal()方法，导致B/C一直被阻塞，main线程退出，但是子线程还在，发生死锁，后面循环也不会继续
                aCon.await();
            }
            Thread.sleep(200);
            System.out.println(Thread.currentThread().getName());
            bCon.signal();
            flag = 2;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB() {
        lock.lock();
        try {
            while (2 != flag) {
                bCon.await();
            }
            Thread.sleep(200);
            System.out.println(Thread.currentThread().getName());
            cCon.signal();
            flag = 3;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC() {
        lock.lock();
        try {
            while (3 != flag) {
                cCon.await();
            }
            Thread.sleep(200);
            System.out.println(Thread.currentThread().getName());
            aCon.signal();
            flag = 1;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

//测试方法
public class test {
    public static void main(String[] args) {
        PrintABC printABC = new PrintABC();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    printABC.printA();
                }
            }
        }, "A").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    printABC.printB();
                }
            }
        }, "B").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    printABC.printC();
                }
            }
        }, "C").start();
    }
}
松鼠MaSaKi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
生产者-消费者模式
whutrenzhe的博客
12-02 496
生产者 - 消费者模式的优点 生产者 - 消费者模式的核心是一个任务队列，生产者线程生产任务，并将任务添加到任务队列中，而消费者线程从任务队列中获取任务并执行。下面是生产者 - 消费者模式的一个示意图，你可以结合它来理解。 生产者 - 消费者模式示意图 从架构设计的角度来看，生产者 - 消费者模式有一个很重要的优点，就是解耦。解耦对于大型系统的设计非常重要，而解耦的一个关键就是组件之间的依赖关系和通信方式必须受限。在生产者 - 消费者模式中，生产者和消费者没有任何依赖关系，它们彼此之间的通信只能通过任务队
多线程通信（二）生产者/消费者模式
Morgan_Xiang的专栏
05-31 749
        生产者/消费者模式其原理是基于wait/notify实现的。        通过代码更能便于理解，废话不多说，上代码。        生成者和消费者一对一模式        生产者public class Producer { private String obj; public Producer(String obj){ super(); ...
线程通信（生产者和消费者）
wt5264的博客
11-16 1429
1.分析 这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件。 对于生产者，没有生产产品之前，要通知消费者等待，而生产了产品之后，有需要马上通知消费者消费 对于消费者，消费完之后，要通知生产者已经结束消费，需要生产新的产品以供消费 生产者消费者问题中，仅有synchronized是不够的 synchronized可阻止并发更新同一个共享资源，实现了同步 synchronized不能用来实现不同线程之纪检的消息传递 2.线程通信提供的方法 方法名
JAVA多线程（8）：线程通信Condition实现生产者和消费者
小蚯蚓的博客
03-18 217
一、线程通信Condition 基于Lock锁的线程通信，可以通过Condition对象实现。Condition对象可以通过lock.newCondition()生成。 线程通信方法await、signal和signalAll，是和sychronized的通信方法wait，notify和notifyAll一一对应。 二、实现代码实例 参考：https://blog.csdn.net/u010...
【Java多线程】多线程之间实现通讯与生产者与消费者模式
HTN_MK的博客
08-25 371
Q：JAVA中如何实现线程通讯？ A：使用wait()、notify()、notifyAll()方法。 Q：什么是生产者与消费者模式？ A：假设有一间有最大容量的仓库，生产者生产商品存放在仓库，消费者购买商品从仓库中取货，仓库里货物为零时，消费者不能取出货物，仓库装满了，生产者不能继续生产货物。在程序中符合这种状态的模式称为生产者与消费者模式。 直接上代码 Test.java
Java——生产者-消费者问题
12-21
本程序模拟实现了“生产者-消费者”问题的解决过程，用图形界面动态演示了P、V操作过程以及生产者、消费者进程之间的... 在程序运行过程中使用了两个生产者线程和两个消费者线程并发工作，并使用了线程随机休眠的策略，
Java 线程间通信，生产者与消费者模型
07-26
使用wait()和notify()实现的生产者与消费者模型，可以了解如何使用wait()和notify()进行线程间通信。（上一次上传的代码有一个问题没有考虑到，这次修补了——CSDN没法撤销资源，只能再上传了）
线程操作案例——生产者和消费者
08-06
NULL 博文链接：https://chaoyi.iteye.com/blog/2080733
java—多线程的通信、生产者与消费者模式
12-21
isDaemon 判断是否为守护线程。 run方法是不能用synchronized修饰，他是继承来的，不能改变其结构，而且，如果run方法加了synchronized，就变成单线程了，就没有并发了。 只要不是静态的同步方法，同步方法默认的...
生产者和消费者模式多线程
07-26
使用多线程实现了生产者和消费者模式
多线程之间实现通讯（生产者与消费者）
u013429010的博客
10-10 944
多线程之间通讯实现（并解决线程安全问题） class Res { public String userName; public String sex; } class InputThread extends Thread { private Res res; public InputThread(Res res) { this.res = res...
线程笔记2--线程的通信（生产者与消费者案例分析）
bangbangbon的博客
11-12 262
线程通信 1、线程通信:不同的线程执行不同的任务,如果这些任务有某种关系,线程之间必须能够通信,协调完成工作，线程通信是相互间状态的切换。 2、线程通信-wait和notify方法介绍: java.lang.Object类提供类两类用于操作线程通信的方法. wait():执行该方法的线程对象释放同步锁,JVM把该线程存放到等待池中,等待其他的
13线程通信(生产者消费者模式)
yuan_boss的博客
07-15 136
线程通信之生产者消费者模式 生产者消费者模式不是23种设计模式之一，它是一个问题 这是一个线程同步的问题，生产者和消费者共享一个资源，并且生产者和消费者之间相互依赖，互为条件 对于生产者，没有生产产品之前，需要通知消费者等待(wait)，而生产了产品之后需要通知消费者消费（唤醒notifAll) 对于消费者，在消费之后，要通知生产者已结束消费，需要生产新的产品来提供消费 在生产者消费者问题中仅有synchronized是不够的，他可阻止并发更新同一个共享资源，实现了同步，但是不能实现不同线程之间的 通信 J
线程通信-生产者消费者模式
weixin_44164943的博客
04-08 112
什么是生产者消费者模式 生产者与消费者模式就是一个多线程并发协作的模式，在这个模式中，有的线程处理数据而产生的结果集是另一部分线程所需处理的数据源，于是便有了形象的生产者与消费者了。这里的生产者便是产生结果集的线程，消费者就是对结果集进行再处理的线程。而为了更好的优化生产者与消费者的关系，便设立一个缓冲区，也就相当于一个数据仓库，当生产者生产数据时锁住仓库，不让消费者访问，当消费者消费时锁住仓库，不让生产者访问仓库。 下面是java代码实现 /** * 生产者消费者模型--> 利用缓冲区解决：管程法
线程间的通信-生产消费者模式
yxpjx的专栏
04-08 1276
<br />JAVA线程间通信问题 <br /><br />有很多现实问题要求不仅要同步的访问同一共享资源，而且线程间还彼此牵制，通过相互通信来向前推进。那么，多个线程之间是如何进行通信的呢？ <br /><br /><br /><br />解决思路 <br />在现实应用中，很多时候都需要让多个线程按照一定的次序来访问共享资源，例如，经典的生产者和消费者问题。这类问题描述了这样一种情况，假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中的产品取走消费。如果仓库中没有产品，则生产者可
线程----线程间通信（生产者消费者模式）
weixin_45335305的博客
02-19 118
案例：生产者生产水果，如果水果没有被买走那么就不生产处于等待状态，如果水果被消费者买走，消费者就会通知生产者再生产水果，生产者生产完水果就通知消费者来买水果 注意： 1.线程间的通信，共享的数据一定要有同步代码块synchronized 2.一定要有wait和notify，而且二者一定是成对出现 3.生产者和消费者的线程实现一定是在while(true)里面 public class Basket...
生产消费者模型
05-11 155
文章目录一、生产者消费者模型是什么？二、代码三、常见面试题说说 sleep() 方法和 wait() 方法区别和共同点为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法一个线程两次调用start()方法会出现什么情况 一、生产者消费者模型是什么？ 其实生产者消费者模型就是线程之间的通信，因为听名字就知道这个模型肯定有两个人，一个是生产者，一个是消费者，生产者一边生产，消费者一边消费。这两个线程同时进行，并且是对同一个物体进行操作，所以涉及到这两个线程的
生产者消费者模式
m0_59749255的博客
08-24 256
有了生产者/消费者模型，生产者和消费者就是两个独立的并发体，生产者把生产出来的数据往缓冲区一丢就好了，不必管消费者；消费者也是，从缓冲区去拿数据就好了，也不必管生产者，缓冲区满了就不生产，缓冲区空了就不消费，使生产者/消费者的处理能力达到一个。因为多了一个缓冲区，所以生产者和消费者并不直接相互调用，这一点很容易想到，这样生产者和消费者的代码发生变化，都不会对对方产生影响，这样其实就把生产者和消费者之间的强耦合解开，变为了生产者和缓冲区/消费者和缓冲区之间的弱耦合。//存储多个数据的生产者/消费者模型。...
线程间通信(生产者与消费者问题)
暖心~的博客
09-30 389
线程间通信：不同种类的线程针对同一个资源的操作。 通过设置线程(生产者)和获取线程(消费者)针对同一个学生对象进行操作。正常情况下应该是： 1、生产者：先看有没有数据，有就等待，没有就生产 2、消费者：先看有没有数据，有就消费，没有就等待等待唤醒机制Object类提供了3个方法： wait()：等待 notify()：唤醒单个线程 notifyAll()：唤醒所有线程 这些方法的调用必
PV操作——生产者消费者问题C++代码
最新发布
05-31
以下是使用C++中的线程库`<thread>`、互斥锁`std::mutex`和条件变量`std::condition_variable`实现生产者消费者问题的示例代码： ```c++ #include #include #include #include #include #include #include ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值