线程操作案例——生产者与消费者（java)

已于 2023-08-08 19:40:58 修改
阅读量322 收藏
点赞数
分类专栏： java初级 文章标签： java 开发语言
于 2023-08-08 19:37:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68536532/article/details/132171679
版权

在线程操作中有一个经典的案例程序——生产者与消费者问题，即生产者不断生产，消费者不断取走生产者所生产的产品。

温馨提示：如果不想看分析过程，可以直接看目录的3.完整代码。

1. 基本实现

1)Info.java(信息类）

因为现在程序中生产者不断生产的是信息，而消费者取出的也是信息，所以定义一个保存信息的Info.java类。

public class Info {                 //定义信息类
    private String name="李兴华";    //信息名称，指定默认值
    private String content="JAVA讲师"; //信息内容，指定默认值

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

2）Producer.java(生产者）

生产者和消费者现在要操作同一空间的内容，属于两个不同的线程，我们均采用实现接口Runnable来设置线程。

public class Producer implements Runnable{
    private Info info;      //保存Info引用，生产信息
    public Producer(Info info){  //通过构造方法设置info内容
        this.info=info;
    }
    @Override
    public void run() {      //覆写run()方法，来生产信息（这里设置50条交替信息）
        boolean flag=true;    //通过flag实现两组信息的交替设置
        for(int i=0;i<50;i++){
            if(flag){
                this.info.setName("李兴华");
                try {
                    Thread.sleep(300);    //添加睡眠，使得效果更加明显
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                this.info.setContent("JAVA讲师");
                flag=false;
            }else{
                this.info.setName("mldn");
                try {
                    Thread.sleep(300);    //添加睡眠，使得效果更加明显
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                this.info.setContent("www.mldnjava.cn");
                flag=true;
            }
        }
    }
}

3) Consumer.java(消费者）

可以直接理解成将info的内容拿出来

public class Consumer implements Runnable{
    private Info info;
    public Consumer(Info info){
        this.info=info;
    }
    @Override
    public void run() {     //覆写run()方法，取出info信息
        for(int i=0;i<50;i++){    //循环取得50次信息（与生产者生产保持一致）
            try {
                Thread.sleep(300);    //添加休眠，使得效果更加明显
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(this.info.getName()+"-->"+this.info.getContent());
        }
    }
}

4)ThreadCaseDemo01.java(主方法）

public class ThreadCaseDemo01 {
    public static void main(String args[]){
        Info i=new Info();    //实例化Info对象
        Producer pro=new Producer(i);
        Consumer con =new Consumer(i);
        new Thread(pro).start();
        new Thread(con).start();
    }
}

运行结果(部分）：

2. 出现的问题

1）信息的题目与内容不匹配-->假设生产者线程刚向数据存储空间添加了信息的名称，还没有加入这信息的内容时，程序就切换到了消费者线程，消费者线程就会把这次信息的名称和上一个信息的内容匹配在一起。

2）重复存取问题-->生产者放入了若干次数据，消费者才开始取数据，或者是消费者取完一个数据后，还没有等到消费放入新的数据，又重复取已经取过的数据。

2.1 问题解决1——加入同步

为了让信息的题目与内容相匹配，我们在存取数据时，给姓名和内容添加同步。为了方便，我们直接在Info类添加自定义方法set()和get()来存取数据。

修改如下：

1)Info.java(信息类）

public class Info {                 //定义信息类
    private String name="李兴华";    //信息名称，指定默认值
    private String content="JAVA讲师"; //信息内容，指定默认值

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
    public synchronized void set(String name,String content){
        this.name=name;
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        this.content=content;
    }
    public synchronized void get(){
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(this.getName()+"-->"+this.getContent());
    }

}

然后生产者类和消费者类也应该进行相应修改

2）Producer.java(生产者）

public class Producer implements Runnable{
    private Info info;      //保存Info引用，生产信息
    public Producer(Info info){  //通过构造方法设置info内容
        this.info=info;
    }
    @Override
    public void run() {      //覆写run()方法，来生产信息（这里设置50条交替信息）
        boolean flag=true;    //通过flag实现两组信息的交替设置
        for(int i=0;i<50;i++){
            if(flag){
                this.info.set("李兴华","JAVA讲师");
                flag=false;
            }else{
                this.info.set("mldn","wwww.mldnjava.cn");
                flag=true;
            }
        }
    }
}

3) Consumer.java(消费者）

public class Consumer implements Runnable{
    private Info info;
    public Consumer(Info info){
        this.info=info;
    }
    @Override
    public void run() {     //覆写run()方法，取出info信息
        for(int i=0;i<50;i++){    //循环取得50次信息（与生产者生产保持一致）
           this.info.get();
        }
    }
}

结果：

从结果可以看出问题1已经解决，然后我们来解决问题2.

2.2 问题解决2——加入等待与唤醒

        如果想让生产者不重复生产，消费者不充分取走，则可以添加一个标志位flag(boolean型）。如果flag为true,表示可以生产，但是不能取走，如果此线程执行到了消费者线程，则应该等待；

如果flag为false,表示可以取走，但是不能生产，如果此线程执行到了生产者线程，则应该等待。

（也就是实现生产一个取一个）

在这里线程的等待和唤醒我们用Object类对线程的一些方法：

方法类型描述
public final void wait() throws InterruptedException普通线程等待
public final void notify()普通唤醒第一个等待的线程
public final void notifyAll()普通唤醒全部等待线程

这里只需要修改Info类即可：

public class Info {                 //定义信息类
    private String name="李兴华";    //信息名称，指定默认值
    private String content="JAVA讲师"; //信息内容，指定默认值
    private boolean flag=true;      //设置标志位
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
    public synchronized void set(String name,String content){   //用于生产者
        if(!flag){              //flag为false,不能生产，需要等待消费者消费
            try {
                super.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        this.name=name;        //flag为true的情况，需要生产者生产
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        this.content=content;
        flag=false;           //修改标志位
        super.notify();       //当生产者产生信息后，唤醒消费者进程
    }
    public synchronized void get(){
        if(flag){           //当flag为true,该生产者生产，消费者需等待
            try {
                super.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(this.getName()+"-->"+this.getContent());
        flag=true;
        super.notify();    //当消费者取出信息后，唤醒生产者进程
    }

}

 结果：（部分）

完美解决

3. 完整代码

1)Info.java(信息类）

public class Info {                 //定义信息类
    private String name="李兴华";    //信息名称，指定默认值
    private String content="JAVA讲师"; //信息内容，指定默认值
    private boolean flag=true;      //设置标志位
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
    public synchronized void set(String name,String content){   //用于生产者
        if(!flag){              //flag为false,不能生产，需要等待消费者消费
            try {
                super.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        this.name=name;        //flag为true的情况，需要生产者生产
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        this.content=content;
        flag=false;           //修改标志位
        super.notify();       //当生产者产生信息后，唤醒消费者进程
    }
    public synchronized void get(){
        if(flag){           //当flag为true,该生产者生产，消费者需等待
            try {
                super.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(this.getName()+"-->"+this.getContent());
        flag=true;
        super.notify();    //当消费者取出信息后，唤醒生产者进程
    }

}

2）Producer.java(生产者）

public class Producer implements Runnable{
    private Info info;      //保存Info引用，生产信息
    public Producer(Info info){  //通过构造方法设置info内容
        this.info=info;
    }
    @Override
    public void run() {      //覆写run()方法，来生产信息（这里设置50条交替信息）
        boolean flag=true;    //通过flag实现两组信息的交替设置
        for(int i=0;i<50;i++){
            if(flag){
                this.info.set("李兴华","JAVA讲师");
                flag=false;
            }else{
                this.info.set("mldn","wwww.mldnjava.cn");
                flag=true;
            }
        }
    }
}

3) Consumer.java(消费者）

public class Consumer implements Runnable{
    private Info info;
    public Consumer(Info info){
        this.info=info;
    }
    @Override
    public void run() {     //覆写run()方法，取出info信息
        for(int i=0;i<50;i++){    //循环取得50次信息（与生产者生产保持一致）
           this.info.get();
        }
    }
}

4.)ThreadCaseDemo01.java(主方法）

public class ThreadCaseDemo01 {
    public static void main(String args[]){
        Info i=new Info();    //实例化Info对象
        Producer pro=new Producer(i);
        Consumer con =new Consumer(i);
        new Thread(pro).start();
        new Thread(con).start();
    }
}

结果（部分）：

4. 总结

 此代码只是简单实现了生产者与消费者每次先生产后消费的情况，利用同步和Object提供线程的等待与唤醒实现该功能，但是没有提供排队序列这个功能，存在一定不足。

柚131
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java生产者消费者的五种实现方式
zgj12138的博客
06-30 4424
前言生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。 现在用四种方式来实现生产者消费者模型
线程操作实例——生产者及消费者
qq_46224953的博客
05-13 478
线程操作案例——生产者及消费者 线程操作中有一个经典案例程序——生产者消费者问题，即生产者不断生产，消费者不断取走生产者生的产品 首先定义一个保存信息的类Info.java class Info { //信息默认值 private String name = "李兴华"; private String content = "Java讲师"; public String getName(){ return name; } public
基于JAVA的生产者消费者问题
11-30 106
在操作系统课上的一点小感想，基于JAVA的生产者消费者问题，分享出来和大家一起学习。 同步机制，首先采用Java的synchronized来实现对缓冲区的互斥访问，再设置一个信号量来实现对缓冲区为空和为满的状态标记。生产者通过在synchronized同步代码块中先对缓冲区是否为满作出判断，若缓冲区为满，将当前线程添加到缓冲区的等待列表中，线程阻塞，并且在...
基于Java代码实现生产者和消费者
最新发布
2203_75607361的博客
08-08 429
基于Java代码实现生产者和消费者
生产者消费者问题、Java实现
热门推荐
「有且仅有」
05-10 1万+
生产者消费者问题（Producer-consumer problem）也可以叫有限缓冲问题（Bounded-buffer problem），是一个经典的进程/线程同步问题。
操作系统 生产者消费者问题 Java代码
01-04
生产者消费者问题，描述一组生产者向一组消费者提供产品/消息。它们共享一个有界缓冲区，生产者向其中放产品/消息，消费者从中取产品/消息。只要缓冲区未满，生产者可放产品/消息，只要缓冲区有数据，消费者可取消息。即应满足下列二个同步条件： 1.只有在缓冲池中至少有一个缓冲区已存入消息后，消费者才能从中提取消息，否则消费者必须等待。 2.只有缓冲池中至少有一个缓冲区是空时，生产者才能把消息放入缓冲区，否则生产者必须等待。 设计要求： 要求设定一个缓冲池中有n个缓冲区，每个缓冲区存放一个消息，创建多个生产者，消费者，并在每个生产者消费者创建时、发出放/取产品申请时、正在放/取产品时和放/取产品结束时分别给出提示信息，并显示取/方产品前后的缓冲区状态，以检查所有处理都遵守相应的操作限制。
生产者消费者问题JAVA实现代码
05-09
os课程设计、通过研究Linux 的进程机制和信号量实现生产者消费者问题的并发控制
线程（生产者和消费者案例）
qq_45788193的博客
03-20 100
StringBuffer:线程安全，可变的字符序列，从JDK5开始，被StringBuilder替代，通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步。优先级高仅仅表示线程获取的CPU时间片的几率高，但是要在比较次数比较多，或者多次运行的时候才能看到你想要的结果。抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程。分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片。
Java——线程之生产者消费者
smile4548656的博客
04-24 1445
Java——线程之生产者消费者一、生产者消费者模式概述二、生产者消费者案例 一、生产者消费者模式概述 生产者消费者模式是一个经典的多线程协作的模式。生产者消费者问题主要包含两类线程： 生产者线程：生产数据 消费者线程：消费数据 为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库： 生产者生成数据后直接放置在共享数据区中，并不需要关心消费者的行为 消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为 为了体现生产和消费过程中的等待和唤醒，Java提供了几个方法，这几个方
进程同步-生产者和消费者（PV操作实现——java多线程模拟）
启人zhr的博客
12-29 9880
进程同步-生产者和消费者（PV操作实现——java多线程模拟）目录进程同步-生产者和消费者PV操作实现java多线程模拟 目录 生产者和消费者概述 PV操作解决生产者和消费者 任务要求 程序代码 运行结果 生产者和消费者概述 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的
【线程】——生产者消费者模型
wkh18891843165的博客
03-23 354
多线程经典示例——生产者消费者模型 所谓的生产者消费者模型，是通过一个容器来解决生产者和消费者的强耦合问题。通俗的讲，就是生产者在不断的生产，消费者也在不断的消费，可是消费者消费的产品是生产者生产的，这就必然存在一个中间容器，我们可以把这个容器想象成是一个货架，当货架空的时候，生产者要生产产品，此时消费者在等待生产者往货架上生产产品，而当货架满的时候，消费者可以从货架上拿走商品，生产者此时等待货架的空位，这样不断的循环。那么在这个过程中，生产者和消费者是不直接接触的，所谓的‘货架’其实就是一个阻塞队列，生产
生产者消费者问题 Java
07-07
用 GUI 实现生产者消费者问题，很直观，CMD 下也有显示 不是用 eclipse 编写，所有不是工程文件，在 CMD 下运行 Main.java 即可
操作系统生产者消费者问题java完整代码
04-21
用java编写，模拟生产者消费者问题，生产一个消费一个！
完整的生产者消费者程序
04-03
包括所有的主程序和线程的cpp和h文件，不同于网上已有的只有线程文件且有错的程序。
【java 多线程】多线程并发同步问题及生产者、消费者问题
木鲸鱼
11-23 3283
一、线程并发同步概念 线程同步其核心就在于一个“同”。所谓“同”就是协同、协助、配合，“同步”就是协同步调昨，也就是按照预定的先后顺序进行运行，即“你先，我等， 你做完，我再做”。 线程同步，就是当线程发出一个功能调用时，在没有得到结果之前，该调用就不会返回，其他线程也不能调用该方法。 就一般而言，我们在说同步、异步的时候，特指那些需要其他组件来配合或者需要一定时间来完成的任务。
生产者消费者程序
weixin_30639719的博客
12-06 119
package learnJava_Thread;/** * * @author wrh * 2011/12/06 * use multithread to complete producer and consumer problem */public class TestProducer_Consumer { public static void main(String[] arg...
java 生产者消费者_一看就懂！Java 代码解决生产者/消费者问题（编程实例 ）
weixin_39612540的博客
12-02 123
生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，如下图所示，生产者向空间里存放数据，而消费者取用数据，如果不加以协调可能会出现以下情况：存储空间已满，而生产者占用着它，消费者等着生产者让出空间从而去除产品，生产者等着消费者消费产品，从而向空间中添加产品。互相等待，从而发生死锁。 以下实例演示了如何通过线程解决生产者/消费者问题：/* author by ...
多线程题目：生产者/消费者问题
qq_44923467的博客
07-11 231
题目：   生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20)，如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产;如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
Java线程生产者消费者问题详解与实例
在Java线程编程中，"生产者与消费者"（Producer-Consumer）问题是一个经典示例，用于展示多线程环境中的并发控制和同步机制。它涉及两个角色：生产者和消费者，它们分别代表线程，一个负责创建产品（数据），另一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值