java多线程——生产者与消费者模型

已于 2022-10-18 19:30:09 修改
阅读量480 收藏 3
点赞数
文章标签： java jvm servlet
于 2022-09-18 10:49:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuochangping/article/details/126914862
版权

一个生产者，一个消费者：

1.让生产者线程和消费者线程 共同操作同一个手机对象(资源)

2.让两个产品来回切换（目的是放大第一个步骤的问题）加锁，防止脏数据的出现

3.生产一个消费一个代码实现：

public class Test01 {
    
    public static void main(String[] args) {

        Phone phone = new Phone();
        
        Producer p = new Producer(phone);
        Consumer c = new Consumer(phone);
        
        p.start();
        c.start();
        
    }

}

package com.dream.producer_consumer01_type01;

public class Phone {
    
    private String brand;
    private double price;
    private boolean isStore;
    
    public boolean isStore() {
        return isStore;
    }

    public void setStore(boolean isStore) {
        this.isStore = isStore;
    }

    public Phone() {
        
    }

    public Phone(String brand, double price, boolean isStore) {
        super();
        this.brand = brand;
        this.price = price;
        this.isStore = isStore;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Phone [brand=" + brand + ", price=" + price + ", isStore=" + isStore + "]";
    }
}
package com.dream.producer_consumer01_type01;

//生产者线程
public class Producer extends Thread{
    
    private Phone phone;
    
    public Producer(Phone phone) {
        this.phone = phone;
    }

    @Override
    public void run() {
        boolean flag = true;
        
        while(true){
            synchronized(phone){
                if(phone.isStore()){//有库存
                    
                    try {
                        phone.wait();//wait：使当前线程等待，并把等待的线程记录在对象监视器（phone）中
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                
                if(flag){
                    phone.setBrand("华为");
                    phone.setPrice(3999);
                }else{
                    phone.setBrand("小米");
                    phone.setPrice(1999);
                }
                flag = !flag;
                phone.setStore(true);//设置为有库存
                
                phone.notify();//唤醒：唤醒对象监视器中第一个等待的线程
            }
            
        }
    }
}

package com.dream.producer_consumer01_type01;

//消费者线程
public class Consumer extends Thread{
    
    private Phone phone;
    
    public Consumer(Phone phone) {
        this.phone = phone;
    }

    @Override
    public void run() {
        while(true){
            synchronized(phone){
                if(!phone.isStore()){//没有库存
                    try {
                        phone.wait();//wait：使当前线程等待，并把等待的线程记录在对象监视器（phone）中
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(phone.getBrand() + " -- " + phone.getPrice());
                phone.setStore(false);//设置成没有库存
                
                phone.notify();//唤醒：唤醒对象监视器中第一个等待的线程
            }
        }
    }
}


2.多个生产者和消费者
代码实现：

public class Test01 {
    
    public static void main(String[] args) {

        Phone phone = new Phone();
        
        Producer p1 = new Producer(phone);
        Producer p2 = new Producer(phone);
        Consumer c1 = new Consumer(phone);
        Consumer c2 = new Consumer(phone)
        
        p1.start();
        p2.start();
        c1.start();
        c2.start();
        
    }

}

package com.dream.producer_consumer01_type01;

public class Phone {
    
    private String brand;
    private double price;
    private boolean isStore;
    
    public boolean isStore() {
        return isStore;
    }

    public void setStore(boolean isStore) {
        this.isStore = isStore;
    }

    public Phone() {
        
    }

    
    public Phone(String brand, double price, boolean isStore) {
        super();
        this.brand = brand;
        this.price = price;
        this.isStore = isStore;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Phone [brand=" + brand + ", price=" + price + ", isStore=" + isStore + "]";
    }
}
package com.dream.producer_consumer01_type01;

//生产者线程
public class Producer extends Thread{
    
    private Phone phone;
    
    public Producer(Phone phone) {
        this.phone = phone;
    }

    @Override
    public void run() {
        boolean flag = true;
        
        while(true){
            synchronized(phone){
                while(phone.isStore()){//有库存
                    
                    try {
                        phone.wait();//wait：使当前线程等待，并把等待的线程记录在对象监视器（phone）中
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                
                if(flag){
                    phone.setBrand("华为");
                    phone.setPrice(3999);
                }else{
                    phone.setBrand("小米");
                    phone.setPrice(1999);
                }
                flag = !flag;
                phone.setStore(true);//设置为有库存
                
                phone.notifyAll();//唤醒：唤醒对象监视器中第一个等待的线程
            }
            
        }
    }
}

package com.dream.producer_consumer01_type01;

//消费者线程
public class Consumer extends Thread{
    
    private Phone phone;
    
    public Consumer(Phone phone) {
        this.phone = phone;
    }

    @Override
    public void run() {
        while(true){
            synchronized(phone){
                while(!phone.isStore()){//没有库存
                    try {
                        phone.wait();//wait：使当前线程等待，并把等待的线程记录在对象监视器（phone）中
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(phone.getBrand() + " -- " + phone.getPrice());
                phone.setStore(false);//设置成没有库存
                
                phone.notifyAll();//唤醒：唤醒对象监视器中第一个等待的线程
            }
        }
    }
}


仓储模型
1.一个生产者一个消费者的情况
代码实现：

public class Test01 {
    
    public static void main(String[] args) {
        
        Store store = new Store();
        
        Producer p = new Producer(store);
        Consumer c = new Consumer(store);
        
        p.start();
        c.start();
    }

}
package com.dream.producer_consumer02_type01;

//蛋糕类
public class Cake {

    private String brand;
    private String dataTime;
    
    public Cake() {
    }

    public Cake(String brand, String dataTime) {
        this.brand = brand;
        this.dataTime = dataTime;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getDataTime() {
        return dataTime;
    }

    public void setDataTime(String dataTime) {
        this.dataTime = dataTime;
    }

    @Override
    public String toString() {
        return "Cake [brand=" + brand + ", dataTime=" + dataTime + "]";
    }
    
}
package com.dream.producer_consumer02_type01;

import java.util.LinkedList;

//仓库类
public class Store {

    //蛋糕容器
    private LinkedList<Cake> list = new LinkedList<>();
    //最大容量
    private int maxCapacity = 20;
    //当前容量
    private int currentCapacity;
    
    //入库
    public void push(Cake cake){
        synchronized (this) {
            if(currentCapacity >= maxCapacity){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            list.add(cake);
            currentCapacity++;
            System.out.println("入库，当前容量为：" + currentCapacity);
            this.notify();
        }
        
    }
    
    //出库
    public void pop(){
        synchronized (this) {
            if(currentCapacity <= 0){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Cake cake = list.removeFirst();
            currentCapacity--;
            System.out.println("出库，当前容量为：" + currentCapacity + " -- " + cake);
        
            this.notify();
        }
    }
}
package com.dream.producer_consumer02_type01;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Producer extends Thread{
    
    private Store store;
    
    public Producer(Store store) {
        this.store = store;
    }

    @Override
    public void run() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        while(true){
            Cake cake = new Cake("桃李面包", sdf.format(new Date()));
            store.push(cake);
        }
    }
}
package com.dream.producer_consumer02_type01;

public class Consumer extends Thread{
    
    private Store store;
    
    public Consumer(Store store) {
        this.store = store;
    }

    @Override
    public void run() {
        while(true){
            store.pop();
        }
    }
}



2.多个生产者和消费者
代码实现：

public class Test01 {
    
    public static void main(String[] args) {
        
        Store store = new Store();
        
        Producer p1 = new Producer(store);
        Producer p2 = new Producer(store);
        Consumer c1 = new Consumer(store);
        Consumer c2 = new Consumer(store);
        
        p1.start();
        p2.start();
        c1.start();
        c2.start();
    }

}
package com.dream.producer_consumer02_type01;

//蛋糕类
public class Cake {

    private String brand;
    private String dataTime;
    
    public Cake() {
    }

    public Cake(String brand, String dataTime) {
        this.brand = brand;
        this.dataTime = dataTime;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getDataTime() {
        return dataTime;
    }

    public void setDataTime(String dataTime) {
        this.dataTime = dataTime;
    }

    @Override
    public String toString() {
        return "Cake [brand=" + brand + ", dataTime=" + dataTime + "]";
    }
    
}
package com.dream.producer_consumer02_type01;

import java.util.LinkedList;

//仓库类
public class Store {

    //蛋糕容器
    private LinkedList<Cake> list = new LinkedList<>();
    //最大容量
    private int maxCapacity = 20;
    //当前容量
    private int currentCapacity;
    
    //入库
    public void push(Cake cake){
        synchronized (this) {
            while(currentCapacity >= maxCapacity){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            list.add(cake);
            currentCapacity++;
            System.out.println("入库，当前容量为：" + currentCapacity);
            this.notifyAll();
        }
        
    }
    
    //出库
    public void pop(){
        synchronized (this) {
            while(currentCapacity <= 0){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Cake cake = list.removeFirst();
            currentCapacity--;
            System.out.println("出库，当前容量为：" + currentCapacity + " -- " + cake);
        
            this.notifyAll();
        }
    }
}
package com.dream.producer_consumer02_type01;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Producer extends Thread{
    
    private Store store;
    
    public Producer(Store store) {
        this.store = store;
    }

    @Override
    public void run() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        while(true){
            Cake cake = new Cake("桃李面包", sdf.format(new Date()));
            store.push(cake);
        }
    }
}
package com.dream.producer_consumer02_type01;

public class Consumer extends Thread{
    
    private Store store;
    
    public Consumer(Store store) {
        this.store = store;
    }

    @Override
    public void run() {
        while(true){
            store.pop();
        }
    }
}
zuo.18
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java实现生产者消费者模型
01-21
Java实现生产者消费者模型 生产者消费者模型，是一般面试题都会考的，下面介绍使用ReetrantLock实现 生产者消费者模型。 定义一个ReentrantLock锁，同时new出两个condition，一个控制队满，一个 控制队空 //生产者 消费者 import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.Executor; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executor
Java中的生产者/消费者模型
u010257931的博客
07-30 3877
生产者-消费者模型（Producer-Consumer problem）是一个非常经典的多线程并发协作的模型。比如某个模块负责生产数据，而另一个模块负责处理数据。产生数据的模块就形象地被称为生产者；而处理数据的模块，则被称为消费者。生产者和消费者在同一段时间内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。
java生产者消费者模型
有个疙叫瘩儿的博客
12-14 4835
前言 生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。 基于synchronized配合wait()和notify()方法的实现 这也是最简单最基础的实现，缓冲区满和为空时都调用wait()方法等待，当生产者生产了一个产品或者消费者消费了一个产品之后会唤醒所有线程。 public class Test...
设计模式：生产者消费者模式
dghh81279的博客
08-30 476
在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。 为什么要使用生产者和消费者模式？ 在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大...
java初学者必看
02-24
最近正在学习Java，也买了很多的有关Java方面的书籍，其中发现《跟我学Java》这本书，都的很不错啊，所以顺便拿电脑把这本书的目录敲了下来，与大家分享。尤其是那些和我一样初学Java的朋友们，看看哪一节对你有用，...
java源码包---java 源码 大量 实例
04-18
　基于JAVA的UDP服务器模型源代码，内含UDP服务器端模型和UDP客户端模型两个小程序，向JAVA初学者演示UDP C/S结构的原理。 简单聊天软件CS模式 2个目标文件 一个简单的CS模式的聊天软件,用socket实现,比较简单。 ...
JAVA上百实例源码以及开源项目
01-03
　基于JAVA的UDP服务器模型源代码，内含UDP服务器端模型和UDP客户端模型两个小程序，向JAVA初学者演示UDP C/S结构的原理。 简单聊天软件CS模式 2个目标文件 一个简单的CS模式的聊天软件,用socket实现,比较简单。 ...
java源码包2
04-20
　基于JAVA的UDP服务器模型源代码，内含UDP服务器端模型和UDP客户端模型两个小程序，向JAVA初学者演示UDP C/S结构的原理。 简单聊天软件CS模式 2个目标文件 一个简单的CS模式的聊天软件,用socket实现,比较简单。 ...
java多线程并发 ： 生产者-消费者模型的三种实现方式
火星男孩的分享空间
05-10 2513
生产者生产数据到缓冲区中，消费者从缓冲区中取数据。 如果缓冲区已经满了，则生产者线程阻塞； 如果缓冲区为空，那么消费者线程阻塞。 方式一：synchronized、wait和notify package day4; //wait 和 notify public class ProducerConsumerWithWaitNofity { public static void main(String[] args) { Resource resource = new Resource
Java设计模式之生产者/消费者模式
红日
01-19 4170
一、什么是生产者/消费者模式？ 某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。在生产者与消费者之间在加个缓冲区，我们形象的称之为仓库，生产者负责往仓库了进商品，而消费者负责从仓库里拿商品，这就构成了生产者消费者模式。结构图如下： 二、生产者消费者模式的优点： 1、解耦: 由于有缓冲区的存在，生产者和消费者之间不直接依赖，耦合度降低。 2、支持并发: 由于生产者与消费者是两个独立的
Java中生产者消费者模型
QYgujingjing的专栏
06-30 398
Java中生产者消费者模型
Java多线程08——生产者/消费者模式
QQ156881887的专栏
02-22 1000
多线程环境下，我们经常需要多个线程的并发和相互通信。其中，有一个重要的多线程并发协作模型，即“生产者/消费者模式”。生产者负责生产数据的模块，可以是方法、对象、线程或进程。消费者负责处理数据的模块，可以是方法、对象、线程或进程。缓冲区消费者不能直接使用生产者的数据，在生产者和消费者之间有一个“缓冲区”。生产者将生产好的数据和内容放入“缓冲区”，消费者从“缓冲区”中取走要处理的数据。实现线程的并发协作设置缓冲区后，生产者线程只需要向缓冲区里面放入数据，而不需要去查看消费者消费的情况；
【Java】一文搞懂生产者和消费者模型
qq_43243800的博客
05-31 632
阻塞队列、消息队列、消息队列的作用、阻塞队列和生产者消费费者模型的实现
生产者消费者模型（学习笔记）——java多线程典型案例
最新发布
R_sir007的博客
08-06 552
生产者消费者模型是一种经典的并发编程模型，它描述的是一个共享资源池的问题。在这个模型中，生产者负责生产数据并将数据放入队列中，消费者线程则负责从队列中取出数据并消费。这个队列通常被设计成是线程安全的，以保证生产者和消费者能够同时操作它而不会出现数据错乱的问题。生产者消费者模型是一种非常重要的并发编程模型，它可以广泛应用于各种场景中，比如生产者线程生产数据，消费者线程处理数据，可以用于异步消息处理、多线程数据处理等。
Java多线程（含生产者消费者模式详解）
yangsf_的博客
03-26 6888
Java简单并发问题解决！含生产者消费者模式详解，管程法与信号灯法！
Java基础22 多线程之多生产者多消费者
Xs943的博客
03-11 1750
生产者消费者 包子案例 多个类（称为线程一类，线程二类） 需要一个共有的变量，即将这个变量封装为一个类（称为属性类）的属性，注意属性类的属性修饰符为public公共的，在测试类中new 这个属性类实例化为对象，然后将此对象作为参数传入需要的多个类（线程一，线程二）中，就可以实现共享对象的属性即变量，且多个类（线程一，线程二） 需要定义此对象（属性类）为私有变量，并提供有参构造 生产者线程和消费者线程要有共享对象，即将包子提升为类作为参数传入生产者线程和消费者线程，这个包子类就是共享的对象，就可以使用 syn
Java多线程：生产者消费者模型
流楚丶格念的博客
07-16 1931
一类是生产者线程用于生产数据一类是消费者线程用于消费数据为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为我们来看一个经典案例，可经典了，上课学，代码学，很多地方都会学到。...
Java中的生产消费者模型（含示例代码）
cyitzz的博客
04-12 799
在Java中，生产消费者模型机制通常用于多线程以及共享内存的机制。生产者和消费者之间共享一个缓冲区。生产者将生成的数据放入缓冲区，消费者从缓冲区中获取数据并进行处理。这种方式可以提高数据处理的效率，尤其是在生产者和消费者之间存在明显的速度差异时。
用java实现多线程消费者和生产者模型
02-26
好的，以下是一个使用Java语言实现的生产者和消费者模型的示例： ``` import java.util.LinkedList; public class ProducerConsumerExample { public static void main(String[] args) { LinkedList<Integer> ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值