java--生产与消费者模型

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

目录

1 几个重要的方法

1.1 wait()方法

1.2 notify()方法

1.3 notifyAll()方法

2 单线程生产与消费者模型

2.1 改进前的模型

2.1 改进后的模型

3 多线程生产与消费者模型

3.1 有限个生产者和消费者

3.2 多个生产者和消费者

1 几个重要的方法

1.1 wait()方法

使线程停止运行，会释放对象锁。

a. 该方法的三个特点：

  • wait()方法会使当前线程调用该方法后进行等待，并且将该线程置入锁对象的等待队列中，直到接到通知或中断为止
  • wait()方法只能在同步方法或同步代码块中调用，如果调用wait()方法时没有适当的锁，会抛出异常
  • wait()方法执行后，当前线程释放锁，其他线程可以竞争该锁

b. wait()之后的线程继续执行的方法：

  • 调用该对象的notify()方法唤醒线程
  • 线程等待时调用interrupt()进行中断

1.2 notify()方法

唤醒线程

该方法的特点：

  •  notify( )方法也必须在同步方法或同步代码块中调用，用来唤醒等待在该对象上的线程，如果有多个线程等待，则任意挑选一个线程唤醒。
  •  notify( )方法执行后，唤醒线程不会立即释放对象锁，要等待唤醒线程全部执行完毕后才释放对象锁

1.3 notifyAll()方法

唤醒所有在该对象上等待的线程

2 单线程生产与消费者模型

2.1 改进前的模型

class Goods{
    private String goodsName;
    private int count;
    //生产商品方法
    public synchronized void set(String goodsName){
        this.goodsName = goodsName;
        this.count++;
        System.out.println(Thread.currentThread().getName()+"生产"+goodsName+toString());
    }
    //消费商品方法
    public synchronized void get(){
        this.goodsName = goodsName;
        this.count--;
        System.out.println(Thread.currentThread().getName()+"消费"+goodsName+toString());
    }
    public String toString() {
        return "Goods{" +
                "goodsName='" + goodsName + '\'' +
                ", count=" + count +
                '}';
    }
}
class Consume implements Runnable{
    private Goods goods;
    public Consume(Goods goods) {
        this.goods = goods;
    }
    public void run() {
        goods.get();
    }
}
class Produce implements Runnable{
    private Goods goods;
    public Produce(Goods goods) {
        this.goods = goods;
    }
    public void run() {
        goods.set("爱豆");
    }
}
public class Test{
    public static void main(String[] args) throws InterruptedException {
        Goods goods = new Goods();
        Thread consumeThread = new Thread(new Consume(goods));
        Thread produceThread = new Thread(new Produce(goods));
        produceThread.start();
        Thread.sleep(2000);
        consumeThread.start();
    }
}

运行结果：

但如果将代码改成先调用消费者线程，如下代码，则会出现消费为负数的情形：

public class Test{
    public static void main(String[] args) throws InterruptedException {
        Goods goods = new Goods();
        Thread consumeThread = new Thread(new Consume(goods));
        Thread produceThread = new Thread(new Produce(goods));
        consumeThread.start();
        Thread.sleep(2000);
        produceThread.start();
    }
}

运行结果：

2.1 改进后的模型

基于上述先消费后生产的情形， 我们可以做如下的改进， 引入wait()和notify()：

class Goods{
    private String goodsName;
    private int count;
    //生产商品方法
    public synchronized void set(String goodsName){
        if(count>0){
            System.out.println("商品还有库存，等会再忙...");
            try {
                //等待消费者消费
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.goodsName = goodsName;
        this.count++;
        System.out.println(Thread.currentThread().getName()+"生产"+goodsName+toString());
        //唤醒等待消费的线程
        notify();
    }
    //消费商品方法
    public synchronized void get(){
        if(count==0){
            System.out.println("商品买完了，等一哈~，马上就到了~~");
            try {
                //等待生产商品
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.goodsName = goodsName;
        this.count--;
        System.out.println(Thread.currentThread().getName()+"消费"+goodsName+toString());
        //唤醒生产者进行生产
        notify();
    }
    public String toString() {
        return "Goods{" +
                "goodsName='" + goodsName + '\'' +
                ", count=" + count +
                '}';
    }
}
class Consume implements Runnable{
    private Goods goods;
    public Consume(Goods goods) {
        this.goods = goods;
    }
    public void run() {
        goods.get();
    }
}
class Produce implements Runnable{
    private Goods goods;
    public Produce(Goods goods) {
        this.goods = goods;
    }
    public void run() {
        goods.set("爱豆");
    }
}
public class Test{
    public static void main(String[] args) throws InterruptedException {
        Goods goods = new Goods();
        Thread consumeThread = new Thread(new Consume(goods),"消费者");
        Thread produceThread = new Thread(new Produce(goods),"生产者");
        consumeThread.start();
        Thread.sleep(2000);
        produceThread.start();
    }
}

运行结果：

这时就不会出现负消费的情形了~

3 多线程生产与消费者模型

3.1 有限个生产者和消费者

class Goods{
    private String goodsName;
    private int count;
    //生产商品方法
    public synchronized void set(String goodsName){
        while (count>0){
            System.out.println("商品还有库存，等会再忙...");
            try {
                //等待消费者消费
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.goodsName = goodsName;
        this.count++;
        System.out.println(Thread.currentThread().getName()+"生产"+goodsName+toString());
        //唤醒等待消费的线程
        notifyAll();
    }
    //消费商品方法
    public synchronized void get(){
        //不断判断执行  注！！！次数不能用if,if判断一次就结束了，程序运行会出现负消费~
        while (count==0){
            System.out.println("商品买完了，等一哈~，马上就到了~~");
            try {
                //等待生产商品
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.goodsName = goodsName;
        this.count--;
        System.out.println(Thread.currentThread().getName()+"消费"+goodsName+toString());
        //唤醒生产者进行生产
        notifyAll();
    }
    public String toString() {
        return "Goods{" +
                "goodsName='" + goodsName + '\'' +
                ", count=" + count +
                '}';
    }
}
class Consume implements Runnable{
    private Goods goods;
    public Consume(Goods goods) {
        this.goods = goods;
    }
    public void run() {
        goods.get();
    }
}
class Produce implements Runnable{
    private Goods goods;
    public Produce(Goods goods) {
        this.goods = goods;
    }
    public void run() {
        goods.set("爱豆");
    }
}
public class Test{
    public static void main(String[] args) throws InterruptedException {
        Goods goods = new Goods();
        //存储多个生产、消费者线程
        List<Thread> list = new ArrayList<>();
        //10个消费者线程
        for(int i = 0;i < 10; i++){
            Thread thread = new Thread(new Consume(goods),"消费者"+i);
            list.add(thread);
        }
        //5个生产者模型
        for(int i = 0;i < 5; i++){
            Thread thread = new Thread(new Produce(goods),"生产者"+i);
            list.add(thread);
        }
        for (Thread thread:list){
            thread.start();
        }
    }
}

运行结果：

3.2 多个生产者和消费者

class Goods{
    private String goodsName;
    private int count;
    public int getCount() {
        return count;
    }
    //生产商品方法
    public synchronized void set(String goodsName){
        /*while (count>0){
            System.out.println("商品还有库存，等会再忙...");
            try {
                //等待消费者消费
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }*/
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.goodsName = goodsName;
        this.count++;
        System.out.println(Thread.currentThread().getName()+"生产"+goodsName+toString());
        //唤醒等待消费的线程
        notifyAll();
    }
    //消费商品方法
    public synchronized void get(){
        //不断判断执行  注！！！次数不能用if,if判断一次就结束了，程序运行会出现负消费~
        while (count==0){
            System.out.println("商品买完了，等一哈~，马上就到了~~");
            try {
                //等待生产商品
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.goodsName = goodsName;
        this.count--;
        System.out.println(Thread.currentThread().getName()+"消费"+goodsName+toString());
        //唤醒生产者进行生产
        notifyAll();
    }
    public String toString() {
        return "Goods{" +
                "goodsName='" + goodsName + '\'' +
                ", count=" + count +
                '}';
    }
}
class Consume implements Runnable{
    private Goods goods;
    public Consume(Goods goods) {
        this.goods = goods;
    }
    public void run() {
        while (true){
            goods.get();
        }
    }
}
class Produce implements Runnable{
    private Goods goods;
    public Produce(Goods goods) {
        this.goods = goods;
    }
    public void run() {
        //限制生产量
        while (this.goods.getCount()<10){
            goods.set("爱豆");
        }
    }
}
public class Test{
    public static void main(String[] args) throws InterruptedException {
        Goods goods = new Goods();
        //存储多个生产、消费者线程
        List<Thread> list = new ArrayList<>();
        //10个消费者线程
        for(int i = 0;i < 10; i++){
            Thread thread = new Thread(new Consume(goods),"消费者"+i);
            list.add(thread);
        }
        //5个生产者模型
        for(int i = 0;i < 5; i++){
            Thread thread = new Thread(new Produce(goods),"生产者"+i);
            list.add(thread);
        }
        for (Thread thread:list){
            thread.start();
        }
    }
}

运行结果是生产者和消费者迭代进行...

易燃易爆炸i
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java---生产者与消费者模式
chenfang0529的博客
07-29 1563
在Java语言中，实现生产者消费者问题时，可以采用三种方式： - 使用 Object 的 wait/notify 的消息通知机制； - 使用 Lock 的 Condition 的 await/signal 的消息通知机制； - 使用 BlockingQueue 实现。
Java生产者-消费者-仓储 模型
大胡子康贝勒爷
03-08 1106
Java生产者消费者模型 文章目录Java生产者消费者模型介绍理解规则分析预备知识代码实现思路实现总结 介绍 理解 现有如下需求，需要用Java实现以下操作流程： 多个蛋糕师生产蛋糕，多个消费者消费蛋糕； 蛋糕的最大仓库是固定的 蛋糕以先进先出原则出售，先生产的蛋糕先被出售，后生产的蛋糕后出售 若要实现这个过程，要借助Java线程的并发写作来做。 生产着消费者模型，完整称作生产者-消费者-...
生产消费模型
最新发布
m0_69323023的博客
06-07 884
生产者消费者模型———阻塞队列
Java多线程：生产者-消费者模型
子夜的个人博客
02-10 1415
生产者-消费者模型
生产者-消费者模型
一江溪水
11-20 7068
什么是生产者消费者模型 生产者 - 消费者模型（ Producer-consumer problem） 是一个非常经典的多线程并发协作的模型，在分布式系统里非常常见。 这个模型由两类线程和一个缓冲区组成来组成 生产者线程：生产数据，并把数据放在这个队列里面 缓冲区：存放生产者的数据的地方 消费者线程：从队列里面取数据，消费数据 运行流程 生产者和消费者在同一时间段内共用同一个存储空间 生产者往存储空间中添加产品 消费者从存储空间中取走产品 当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。
java生产者消费者模型
有个疙叫瘩儿的博客
12-14 4893
前言 生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。 基于synchronized配合wait()和notify()方法的实现 这也是最简单最基础的实现，缓冲区满和为空时都调用wait()方法等待，当生产者生产了一个产品或者消费者消费了一个产品之后会唤醒所有线程。 public class Test...
Java---实现生产者消费者模型
老高是我
03-06 1686
使用BlockingQueue package concurrent; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; /** * Created by geekgao on 16-3-4. */ public class ProducerAndConsu
Java中的生产者/消费者模型
u010257931的博客
07-30 4492
生产者-消费者模型（Producer-Consumer problem）是一个非常经典的多线程并发协作的模型。比如某个模块负责生产数据，而另一个模块负责处理数据。产生数据的模块就形象地被称为生产者；而处理数据的模块，则被称为消费者。生产者和消费者在同一段时间内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。
Java设计模式之生产者/消费者模式
红日
01-19 4327
一、什么是生产者/消费者模式？ 某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。在生产者与消费者之间在加个缓冲区，我们形象的称之为仓库，生产者负责往仓库了进商品，而消费者负责从仓库里拿商品，这就构成了生产者消费者模式。结构图如下： 二、生产者消费者模式的优点： 1、解耦: 由于有缓冲区的存在，生产者和消费者之间不直接依赖，耦合度降低。 2、支持并发: 由于生产者与消费者是两个独立的
Java：线程同步经典案例-生产者与消费者模型
Xminyang的博客
11-18 2735
一、相关知识简介 在生产者-消费者模型中，若只使用synchronized关键字实现对象锁，程序在运行中可能会出现以下两种情况： 若生产者的速度大于消费者，那么在消费者来不及取前一个数据之前，生产者又产生了新的数据，于是消费者很可能会跳过前一个数据。 若消费者的速度大于生产者，那么消费者可能多次取同一个数据。为了避免上述情况，必须使生产者向object对象中存储数据与消费者从o
Java多线程：生产者消费者模型
流楚丶格念的博客
07-16 1961
一类是生产者线程用于生产数据一类是消费者线程用于消费数据为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为我们来看一个经典案例，可经典了，上课学，代码学，很多地方都会学到。...
Java多线程-生产者与消费者问题
02-03
### Java多线程-生产者与消费者问题 #### 一、生产者与消费者问题概览 **1.1 概要** 生产者与消费者问题是计算机科学中一个多线程同步的经典问题。它描述了两个线程如何共享有限资源的场景：一个是生产者...
Java实现简易生产者消费者模型过程解析
08-19
Java实现简易生产者消费者模型过程解析 一、概述 生产者消费者模型是一种常见的并发编程模型，在Java中可以通过使用同步机制和wait/notify机制来实现。在本文中，我们将通过一个简单的示例代码介绍Java实现简易...
Java多线程 生产者消费者模型实例详解
08-25
Java多线程生产者消费者模型实例详解 Java多线程生产者消费者模型是指在多线程环境下，生产者线程生产任务，消费者线程消费任务，而缓冲区是生产者和消费者之间的媒介。生产者消费者模型的主要组成部分包括生产者...
Java基于Lock的生产者消费者模型示例
08-27
Java基于Lock的生产者消费者模型示例 Java中的生产者消费者模型是指一个线程（生产者）生产数据，并将其存储在缓冲区中，而另一个线程（消费者）从缓冲区中取出数据并进行处理。Java中基于Lock的生产者消费者模型是...
Java多线程 BlockingQueue实现生产者消费者模型详解
08-25
Java多线程BlockingQueue实现生产者消费者模型详解 Java多线程中，生产者消费者模型是非常重要的一种设计模式，它可以解决多线程之间的数据传输问题。在Java中，我们可以使用BlockingQueue来实现生产者消费者模型，...
java中如何查看内存泄露
weixin_43852903的博客
05-11 3395
1 准备工作 首先你的电脑上得有软件查看内存泄露，我们使用notepad++，(记事本打开格式不对~)在此推荐一个微信公众号：软件安装管家，就可以轻松安装该软件啦~ 2 程序休眠、打断点（便于观察） 以下程序以单链表为例： public static void main(String[] args) throws InterruptedException { M...
写两个线程，一个线程打印1~52，另一个线程打印A~Z，打印顺序是12A34B...5152Z
weixin_43852903的博客
05-09 2665
目录 1 题目分析 2 代码实现 3 运行结果 1 题目分析 数字线程的个数是字母线程的2倍 用信号量flag来控制打印的顺序：这里我们假设当flag = 1时打印数字，当flag = 2时打印字母 每轮打印中数字有以下规律：12 34 56 78 ~ 我们不难发现：当我们定义一个计数器count从1计数时，第一组数字为2*count-1、2*count，之后每组数字都遵循这个规律；...
数据结构--java语言实现循环队列
weixin_43852903的博客
05-24 1682
目录 1 题目描述 2 解题思路 3 代码实现 1 题目描述 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能...
Java编程实现生产者－消费者模型
04-08
生产者消费者模型可以通过使用Java中的多线程来实现。一种常见的方法是使用阻塞队列来作为生产者和消费者之间的缓冲区。生产者不断地向队列中添加元素，而消费者则不断地从队列中取出元素。当队列为空时，消费者线程将被阻塞，直到有新的元素被添加到队列中。同样地，当队列满时，生产者线程也将被阻塞，直到有元素被消费。这种方法可以有效地避免生产者和消费者之间的竞争条件和资源争用，实现了高效的并发编程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值