重温java知识（三十七、多线程编程之六-综合案例：生产者与消费者）

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

1、“生产者与消费者”编程的基础模型【
该程序存在两个问题：

  • 数据错位：假设生产者线程刚向数据存储空间添加了信息的名称，还没有加入这个信息的内容，程序就切换到了消费者线程，而消费者线程将把这个信息的名称和上一个信息的内容联系到类一起。
  • 重复操作：生产者放了若干次的数据，消费者才开始取出数据；或者是消费者取完一个数据后，还没等到生产者放入新的数据，又重复取出已取过的数据。
    】：
package com.mydemo;

public class ThreadDemo {

    public static void main(String[] args) {

        // 定义Message对象，用于保存和取出数据
        Message message = new Message();

        // 启动生产者线程
        new Thread(new Producer(message)).start();

        // 取得消费者线程
        new Thread(new Consumer(message)).start();
    }
}

class Message {
    private String title;       // 保存信息的标题
    private String content;     // 保存信息的内容

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

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

// 定义生产者
class Producer implements Runnable {

    private Message msg = null;

    /**
     * 单参构造
     *
     * @param msg
     */
    public Producer(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        // 生产50次数据
        for (int i = 0; i < 50; i++) {
            if (i % 2 == 0) {
                // 设置title属性
                this.msg.setTitle("张三");
                try {
                    // 延迟操作
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.msg.setContent("java讲师");
            } else {
                this.msg.setTitle("李四");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.msg.setContent("JS讲师");
            }
        }
    }
}

// 定义消费者
class Consumer implements Runnable {

    private Message msg = null;

    /**
     * @param msg
     */
    public Consumer(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        // 取走50次
        for (int i = 0; i < 50; i++) {
            try {
                // 延迟
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.msg.getTitle() + "-->" + this.msg.getContent());
        }
    }
}

2-1、解决上面代码数据同步的问题：

package com.mydemo;

public class ThreadDemo {

    public static void main(String[] args) {

        // 定义Message对象，用于保存和取出数据
        Message message = new Message();

        // 启动生产者线程
        new Thread(new Producer(message)).start();

        // 取得消费者线程
        new Thread(new Consumer(message)).start();
    }
}

class Message {
    private String title;       // 保存信息的标题
    private String content;     // 保存信息的内容

    /**
     * 在本程序中，生产者和消费者代表着不同的线程对象，
     * 所以此时的同步操作应该设置在Message类中，
     * 可以将title和content属性设置定义为单独同步方法。
     *
     * 这样使得不同线程在进行公共数据区域操作时都可以保证数据的完整性，
     * 解决了数据设置错乱的问题。
     */

    /**
     * @param title
     * @param content
     */
    public synchronized void set(String title, String content) {
        this.title = title;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.content = content;
    }

    /**
     * @return
     */
    public synchronized String get() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return this.title + "-->" + this.content;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

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

// 定义生产者
class Producer implements Runnable {

    private Message msg = null;

    /**
     * 单参构造
     *
     * @param msg
     */
    public Producer(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        // 生产50次数据
        for (int i = 0; i < 50; i++) {
            if (i % 2 == 0) {
                // 设置title属性
                this.msg.set("张三", "java讲师");
                try {
                    // 延迟操作
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                this.msg.set("李四", "js讲师");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

// 定义消费者
class Consumer implements Runnable {

    private Message msg = null;

    /**
     * @param msg
     */
    public Consumer(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        // 取走50次
        for (int i = 0; i < 50; i++) {
            try {
                // 延迟
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.msg.get());
        }
    }
}

2-2、解决上面代码数据同步的问题【用Object线程等待与唤醒方式】：

package com.mydemo;

public class ThreadDemo {

    public static void main(String[] args) {

        // 定义Message对象，用于保存和取出数据
        Message message = new Message();

        // 启动生产者线程
        new Thread(new Producer(message)).start();

        // 取得消费者线程
        new Thread(new Consumer(message)).start();
    }
}

class Message {
    private String title;           // 保存信息的标题
    private String content;         // 保存信息的内容

    /**
     * 表示生成或消费的形式
     * flag = true： 允许生产，但是不允许消费
     * flag = false：允许消费，但是不允许生成
     */
    private boolean flag = true;

    /**
     * @param title
     * @param content
     */
    public synchronized void set(String title, String content) {

        // 无法进行生成，等待被消费
        if (this.flag == false) {
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.title = title;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.content = content;

        // 已经生产过了
        this.flag = false;

        // 唤醒等待的线程
        super.notify();
    }

    /**
     * @return
     */
    public synchronized String get() {

        // 还未生产，需要等待
        if (this.flag == true) {
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            return this.title + "-->" + this.content;
        } finally {
            // 不管如何都要执行
            this.flag = true;   // 继续生产
            super.notify();     // 唤醒等待线程
        }
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

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

// 定义生产者
class Producer implements Runnable {

    private Message msg = null;

    /**
     * 单参构造
     *
     * @param msg
     */
    public Producer(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        // 生产50次数据
        for (int i = 0; i < 50; i++) {
            if (i % 2 == 0) {
                // 设置title属性
                this.msg.set("张三", "java讲师");
                try {
                    // 延迟操作
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                this.msg.set("李四", "js讲师");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

// 定义消费者
class Consumer implements Runnable {

    private Message msg = null;

    /**
     * @param msg
     */
    public Consumer(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        // 取走50次
        for (int i = 0; i < 50; i++) {
            try {
                // 延迟
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.msg.get());
        }
    }
}
宇智波幽助
关注
专栏目录
对生产者_消费者模型一个拓展需求的问题分析与解决
12-21
生产者消费者模型为进程间传递数据提供了经典方法，但该模型局限于进程的一次运行，当任一进程退出重运行后，该模型下，所有相关进程必须重新初始化资源来达到需要的同步，从而完全丢失缓冲区现有数据。
生产者消费者模型问题
roohom的博客
08-05 413
文章目录典型案例一:milk_glass:牛奶生产者和消费者问题典型案例二:多线程猜数字游戏 Java中的多线程问题 生产者消费者模型是多线程中的典型案例。当多线程在运行过程中涉及到了对共享资源进行修改时，就会引起线程安全问题，为了解决此安全问题，便引入了同步机制。 解决方案: 本质:把多线程变成单线程 引入线程同步机制(三种方法) 同步代码块 针对run方法中的代码，使用synchronized关键字，把部分代码添加同步机制 同步机制:在同一个而时间，只能有一个线程执行 原理:线程在执行之
生产者、消费者问题模型
weixin_42357849的博客
07-11 306
一、模型简介： 生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。 ...
简单写一个生产者与消费者例子
NasubiZW
03-01 1228
1、概要：生产者与消费者其实是一种思想或者说是一种代码的设计模式，生产者往存储空间中放入数据，消费者从存储空间中存储数据。 2、代码： public class TestThread { private final Lock lock = new ReentrantLock(); private final Condition producerCondition = lock.newCondition(); private final Condition consumerCon
关于生产者与消费者的例子
Yemy的专栏
12-08 1201
import java.util.Vector;public class SyncTest { public static void main(String[] args){  SyncTest t = new SyncTest();  final SyncTest.SyncStack ss = t.new SyncStack();  Runnable Producer = new Runnabl
java7源码-ReviewJavaFoundation:重温Java基础系列源代码
06-04
所以，近段时间开始，将重温Java技术的基础知识，主版本为Java8，中间可能也会穿插一些其它版本，如Java7。谨以此系列文章，来记录重温Java基础的历程。 为啥费劲写这些文章？和写SpringCloud进阶之路时一样，一是...
java源码知乎-JavaCodeForBeginners:该存储库将包含面向初学者以及想要复兴其知识的开发人员的源代码。
05-25
7. **多线程**：Java提供了内置的多线程支持，包括Thread类和Runnable接口。理解并发编程的基本概念，如同步、互斥和死锁，有助于编写高效并行程序。 8. **网络编程**：Java的Socket编程允许开发网络应用程序。学习...
深度学习项目开发实战_特征工程与模型复杂性-重温泰坦尼克号示例_编程案例实例课程教程.pdf
最新发布
05-08
特征工程与模型复杂性在深度学习项目开发中扮演着至关重要的角色。特征工程是指通过对原始数据进行转换、组合或选择，创造出对模型预测有贡献的新特征的过程。这一步骤是提升模型性能的关键，因为合适的特征可以使...
java源码导读-Java-open-source-learning:Java学习资源向所有人开放，可以为新的编码爱好者提供帮助，以快速浏览一
05-21
首先，面向对象的分析和设计提供了一些有关这些OOP概念的出色示例，我建议您至少阅读一本书以重温OOP的基础知识。 等于和“ ==”运算符之间的差异-“ ==”运算符比较if实例引用同一对象。 而equals（）是在Java的...
CmpE273-HW1:JavaScript和Java刷新器
05-10
7. **多线程**：Java内置了多线程支持，通过`Thread`类或实现`Runnable`接口创建线程。 8. **JVM与类加载器**：Java代码编译成字节码，由Java虚拟机（JVM）执行。类加载器负责加载类到JVM内存。 9. **泛型**：泛型...
生产者消费者模型（C++）
MyHome
05-16 1570
/* 手撕生产者与消费者模型 * 一个场所，两种角色，三种关系 * 场所：线程 安全的队列 */ #include <iostream> #include <queue> #include <pthread.h> class BlockQueue { public: BlockQueue(int cap = 10):_capacit...
生产者消费者模型
kalvin_y_liu的博客
10-24 6328
将上述场景例比到我们实际的软件开发过程中，经常会见到这样一幕：代码的某个模块负责生产数据（供货商），而生产出来的数据却不得不交给另一模块（消费者）来对其进行处理，在这之间我们必须要有一个类似上述超市的东西来存储数据（超市），这就抽象除了我们的生产者/消费者模型。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
生产者-消费者问题（有例题！！！）
CHEN的博客笔记
08-25 6540
文章目录前言问题描述 前言 此篇文章是我在B站学习时所做的笔记，大部分图片都是课件老师的PPT，方便复习用。此篇文章仅供学习参考。 提示：以下是本篇文章正文内容 问题描述
面试题之：生产者和消费者问题
学习记录
04-27 2512
小米面试问到生产者和消费者问题，当时没答上，所以今天必须补上。。。 要理解生产消费者问题，首先应弄清PV操作的含义：PV操作是由P操作原语和V操作原语组成（原语是不可中断的过程），对信号量进行操作，具体定义如下： P（S）：①将信号量S的值减1，即S=S-1； ②如果S³0，则该进程继续执行；否则该进程置为等待状态，排入等待队列。 V（S）：①将信号量S的值加1，即S=
用多线程实现“生产者-消费者问题”(代码+实验报告)
叶现一的专栏
11-25 1万+
 用多线程实现“生产者-消费者问题”(代码+实验报告) #include  #include  #include  #include  using namespace std;typedef int semaphore;                          /* 信号量是一种特殊的整型变量 */    const int SIZ
生产者与消费者问题C语言实现
热门推荐
徐奕的专栏
05-27 11万+
实验目的 ①实现生产者—消费者问题的模拟，以便更好的理解此经典进程同步问题。生产者－消费者问题是典型的PV操作问题，假设系统中有一个比较大的缓冲池，生产者的任务是只要缓冲池未满就可以将生产出的产品放入其中，而消费者的任务是只要缓冲池未空就可以从缓冲池中拿走产品。缓冲池被占用时，任何进程都不能访问。 ②每一个生产者都要把自己生产的产品放入缓冲池，每个消费者从缓冲池中取走产品消费。在这种情况下，生...
共享内存，共享缓冲区 一对多
u011244446的专栏
08-26 2793
produce: for(int i=0;i if(iter == VecS2SResult.end()){ break; } if(g_Empty_sem_obj[i].sem_trywait()==0){ //获取到信号量 g_push_consume_cache[i].msgid = (*iter)["FmsgId"]; g_push_consume_cache[i].a
生产者消费者问题
junglefly的学习工作纪录
11-28 8439
Normal 0 7.8 磅 0 2 false false false MicrosoftInternetExplorer4 <!-- /* Sty
Qt 生产者消费者模型
axylp123的专栏
08-27 2184
基于QT实现的生产者消费者模型 不足之处请留言指出 //global.h #ifndef GLOBAL_H #define GLOBAL_H #include #include #include extern QMutex g_mutex; extern QWaitCondition g_bufferFull; extern QWaitCo
《重温微积分》- 齐民友：数学与物理的交汇探索
齐民友的《重温微积分》是一本教材，旨在帮助读者深入理解和应用微积分知识，同时为学习更高级的数学和物理学概念做准备。 部分内容中提到了"宅睿獭工作室"对原书的重新排版，这表明提供的内容可能是一个教材或学术...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值