操作系统 生产者消费者 练习

最新推荐文章于 2022-08-20 11:27:31 发布
最新推荐文章于 2022-08-20 11:27:31 发布
阅读量229 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/van9527/article/details/126224488
版权

习题:假设

有10个生产者和10个消费者 

初始物品100个

生产者一次生产一件物品  消费者一次消费一件物品

生产者每生产一件物品  消费者就消费掉一件  

消费者每消费掉一件  生产者就生产一件物品 

直到这样交互100次

思想 :10个消费者为一个线程池  10个生产者为一个线程池

消费者任务  物品--;

生产者任务  物品++;

这里有个条件

1.

每次执行 物品--; 或 物品++;时  我们只想让一个生产者或消费者去执行  其他的人等待  所以这里我们用到了互斥量  同一时刻只允许一个线程执行  

2.

生产者一次生产一件物品  消费者一次消费一件物品

生产者每生产一件物品  消费者就消费掉一件  

这我们可以利用互斥量的信号的获取和释放来实现

当生产者获取到生产者的互斥量信号  它生产一件物品  然后释放掉消费者的互斥量信号  

消费者获取到消费者的互斥量信号  它消费一件物品  然后释放掉生产者的互斥量信号 

如此往复

完整代码如下

生产者消费者类的声明

#ifndef CREATER_H
#define CREATER_H
#include<windows.h>
#include<list>
#include<queue>

class CreaterConsumer
{
private:
    //生产者句柄
    HANDLE m_Create;
    //消费者句柄
    HANDLE m_Consumer;
    //生产者线程链表
    std::list<HANDLE> m_myCreaterlist;
    //消费者线程链表
    std::list<HANDLE> m_myConsumerlist;
    //产品数量
    long product;
    //生产者互斥量
    HANDLE m_MutexCreater;
    //消费者互斥量
    HANDLE m_MutexConsumer;
public:
    //记录交互次数
    long nCount;
public:
    CreaterConsumer();
    ~CreaterConsumer();
    //创建生产者线程池
    bool CreateThreadPool();
    //创建消费者线程池
    bool ConsumerThreadPool();
    //销毁生产者线程池
    void DeleteCreaterThreadPool();
    //销毁消费者线程池
    void DeleteConsumerThreadPool();
    //生产者线程函数
    static DWORD WINAPI CreateThreadProc(LPVOID lpvoid);
    //消费者线程函数
    static DWORD WINAPI ConsumerThreadProc(LPVOID lpvoid);
};

#endif // CREATER_H

生产者消费者类的的定义

#include "creater.h"
#include<iostream>
using namespace std;
CreaterConsumer::CreaterConsumer()
{
     m_Create=NULL;
     m_Consumer=NULL;
     product=100;
     m_MutexCreater=CreateMutex(0,0,0);
     m_MutexConsumer=CreateMutex(0,1,0);//开始先让消费者启动交互
     nCount=0;

}

CreaterConsumer::~CreaterConsumer()
{

}
bool CreaterConsumer::CreateThreadPool()
{
    //创建十个线程到生产者线程列表中去
    for(int  i=0;i<10;i++)
    {
        m_Create=CreateThread(0,0,&CreateThreadProc,this,0,0);
        if(m_Create)
        {
            m_myCreaterlist.push_back(m_Create);
        }
    }


}

bool CreaterConsumer::ConsumerThreadPool()
{
    //创建十个线程到消费者线程列表中去
    for(int  i=0;i<10;i++)
    {
        m_Consumer=CreateThread(0,0,&CreateThreadProc,this,0,0);
        if(m_Consumer)
        {
            m_myConsumerlist.push_back(m_Consumer);
        }
    }
}

DWORD WINAPI CreaterConsumer::CreateThreadProc(LPVOID lpvoid)
{
    CreaterConsumer* pthis=(CreaterConsumer*)lpvoid;
    while(1)
    {
        //当前交互次数小于100
        if(pthis->nCount<100)
        {
            WaitForSingleObject(pthis->m_MutexCreater,INFINITE);
            //当交互次数为 例如:99 时 进来了多个线程
            //如果一个交互次数为99 的线程执行完 交互次数变为100 应该不继续执行
            //但是剩下的进来的这些线程不会出去 会继续执行 交互次数就会大于100 所以加了一个筛选 if(pthis->nCount>=100)

            if(pthis->nCount>=100)
            {
                //如果此时交互次数>=100  剩下的进来的线程不会继续执行  而是会被筛选出去
                ReleaseMutex( pthis->m_MutexConsumer);
                continue;
            }
            //pthis->product++;
            //物品数++
            InterlockedIncrement(&pthis->product);
            //交互次数++
            InterlockedIncrement(&pthis->nCount);
            //打印交互次数
            cout<<pthis->nCount<<endl;
            //释放消费者信号
            ReleaseMutex(pthis->m_MutexConsumer);
        }

    }

}

DWORD WINAPI CreaterConsumer::ConsumerThreadProc(LPVOID lpvoid)
{
    CreaterConsumer* pthis=(CreaterConsumer*)lpvoid;
    while(1)
    {
        if(pthis->nCount<100)
        {
            WaitForSingleObject(pthis->m_MutexConsumer,INFINITE);
            if(pthis->nCount>=100)
            {
                ReleaseMutex( pthis->m_MutexCreater);
                continue;
            }
            //pthis->product--;
            //物品数--;
            InterlockedDecrement(&pthis->product);
            //释放生产者信号
            ReleaseMutex(pthis->m_MutexCreater);
        }



    }



}


void CreaterConsumer::DeleteCreaterThreadPool()
{
    //遍历生产者列表
    auto ite= m_myCreaterlist.begin();
    //将生产者列表的每一项都删除
    while(ite!=m_myCreaterlist.end())
    {
        delete *ite;
        ite++;
    }
    //清空列表
    m_myCreaterlist.clear();

    //释放生产者线程句柄
    if(m_Create)
    {
        CloseHandle(m_Create);
        m_Create=NULL;
    }
    //释放生产者互斥量
    if(m_MutexCreater)
    {
         CloseHandle(m_MutexCreater);
         m_MutexCreater=NULL;
    }
}

void CreaterConsumer::DeleteConsumerThreadPool()
{
    //遍历并删除消费者列表的每一项
    auto ite= m_myConsumerlist.begin();
    while(ite!=m_myConsumerlist.end())
    {
        delete *ite;
        ite++;
    }
    //清空消费者列表
    m_myConsumerlist.clear();

    //释放消费者线程句柄
    if(m_Consumer)
    {
        CloseHandle(m_Consumer);
        m_Consumer=NULL;
    }
    //释放消费者互斥量
    if(m_MutexConsumer)
    {
         CloseHandle(m_MutexConsumer);
         m_MutexConsumer=NULL;
    }

}

主函数

#include "creater.h"
#include<iostream>
using namespace std;
CreaterConsumer::CreaterConsumer()
{
     m_Create=NULL;
     m_Consumer=NULL;
     product=100;
     m_MutexCreater=CreateMutex(0,0,0);
     m_MutexConsumer=CreateMutex(0,1,0);
     nCount=0;

}

CreaterConsumer::~CreaterConsumer()
{

}
bool CreaterConsumer::CreateThreadPool()
{
    //创建十个线程到线程列表中去
    for(int  i=0;i<10;i++)
    {
        m_Create=CreateThread(0,0,&CreateThreadProc,this,0,0);
        if(m_Create)
        {
            m_myCreaterlist.push_back(m_Create);
        }
    }


}

bool CreaterConsumer::ConsumerThreadPool()
{
    //创建十个线程到线程列表中去
    for(int  i=0;i<10;i++)
    {
        m_Consumer=CreateThread(0,0,&CreateThreadProc,this,0,0);
        if(m_Consumer)
        {
            m_myConsumerlist.push_back(m_Consumer);
        }
    }
}

DWORD WINAPI CreaterConsumer::CreateThreadProc(LPVOID lpvoid)
{
    CreaterConsumer* pthis=(CreaterConsumer*)lpvoid;
    while(1)
    {
        if(pthis->nCount<100)
        {
            WaitForSingleObject(pthis->m_MutexCreater,INFINITE);
            if(pthis->nCount>=100)
            {
                ReleaseMutex( pthis->m_MutexConsumer);
                continue;
            }
            //pthis->product++;
            InterlockedIncrement(&pthis->product);
            InterlockedIncrement(&pthis->nCount);
            cout<<pthis->nCount<<endl;
            ReleaseMutex(pthis->m_MutexConsumer);
        }

    }

}

DWORD WINAPI CreaterConsumer::ConsumerThreadProc(LPVOID lpvoid)
{
    CreaterConsumer* pthis=(CreaterConsumer*)lpvoid;
    while(1)
    {
        if(pthis->nCount<100)
        {
            WaitForSingleObject(pthis->m_MutexConsumer,INFINITE);
            if(pthis->nCount>=100)
            {
                ReleaseMutex( pthis->m_MutexCreater);
                continue;
            }
            //pthis->product--;
            InterlockedDecrement(&pthis->product);
            ReleaseMutex(pthis->m_MutexCreater);
        }



    }



}


void CreaterConsumer::DeleteCreaterThreadPool()
{
    auto ite= m_myCreaterlist.begin();
    while(ite!=m_myCreaterlist.end())
    {
        delete *ite;
        ite++;
    }
    m_myCreaterlist.clear();

    if(m_Create)
    {
        CloseHandle(m_Create);
        m_Create=NULL;
    }
    if(m_MutexCreater)
    {
         CloseHandle(m_MutexCreater);
         m_MutexCreater=NULL;
    }
}

void CreaterConsumer::DeleteConsumerThreadPool()
{
    auto ite= m_myConsumerlist.begin();
    while(ite!=m_myConsumerlist.end())
    {
        delete *ite;
        ite++;
    }

    if(m_Consumer)
    {
        CloseHandle(m_Consumer);
        m_Consumer=NULL;
    }
    if(m_MutexConsumer)
    {
         CloseHandle(m_MutexConsumer);
         m_MutexConsumer=NULL;
    }

}

执行结果

交互次数为100 

van9527
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
操作系统中生产者与消费者问题实例
12-18
C#编写的有关操作系统中生产者与消费者问题的实例，画面美观，生动形象的描绘了生产者与消费者之间的关系，代码部分简介易懂。
生产者和消费者问题（操作系统中的经典问题）
05-11
进程中创建多个线程模拟生产者和消费者，并且满足以下要求：生产者可以把产品放到任意缓冲区中，消费者只消费指定生产者的产品，且为各生产者分配缓冲区时，各生产者必须互斥，各生产者的具体活动并发，而消费者只有在对同一产品进行消费时才互斥。
Java多线程---生产者消费者练习题
u011277123的博客
01-10 783
指尖上的Java 2017-01-09 21:39 主页菌又来喽，今天呢，主页菌分享一道关于多线程-生产者消费者的练习题！ 代码： 生产者： 1 1 消费者： 2 资源： 3 3 测试代码： 4 今天的分享就到这里了，我们明天同一时间再见！ 本文为头条号作者发布，不代表今日头条立场。
操作系统-----生产者消费者例题
weixin_50759066的博客
08-20 3924
生产者-消费者例题
操作系统考研习题讲解——生产者消费者习题001
NightPoetry的博客
11-09 1644
目录 生产者消费者问题题解001. 1 常规解题方法/解题思路：... 1 最佳参考答案... 1 题目分析... 3 其他两种参考答案：... 3 生产者消费者问题题解001 本次讲解分为常规解题讲解和题目分析两个部分，只求会解题的同学可以直接看第一部分，有疑问的可以继续看第二部分。 常规解题方法/解题思路： 最佳参考答案 semaphoremutex=1;//互斥使用取号机 semaphoreempty=10;//空座位数量 semaphore...
Visual studio 2008做的生产者消费者操作系统练习
04-21
本项目利用Visual Studio 2008作为开发环境，采用C++语言实现了一个生产者-消费者模型的操作系统练习。 在C++中，解决生产者-消费者问题通常会用到线程、共享内存和信号量等机制。Visual Studio 2008提供了对C++...
操作系统生产者和消费者问题
04-29
操作系统中的“生产者-消费者问题”是一个经典的多线程同步问题，主要涉及到进程间的通信与协作，以确保数据的一致性和正确性。这个问题通常在并发编程中出现，尤其是在多处理器或多核心系统中，多个线程或者进程...
操作系统实验二 ——生产者消费者问题
04-10
总结来说，操作系统实验二的生产者消费者问题是研究进程同步的一个基础练习。它涉及到线程间的协作、信号量机制的运用，以及如何在有限资源下避免数据竞争。通过C语言实现这个模型，学生们可以深入理解并发编程中的...
并行openmp程序实现生产者消费者
06-18
并行OpenMP程序实现生产者消费者模式是一种在多线程编程中常见的设计模式，它能够高效地利用系统资源，提高程序执行效率。OpenMP（Open Multi-Processing）是用于共享内存并行计算的一种API标准，它提供了一种简单的...
操作系统生产者消费者问题
12-10
基于Windows进程互斥分析和模拟 基于Microsoft Visual Studio环境的多线程编程验证互斥的原理，理解多线程编程中关键元素的定义与使用，通过使用Semaphore，mutex等控制元素，实现对生产者消费者模型的真实模拟，函数的功能与实现自己定义。
生产者-消费者问题（有例题！！！）
CHEN的博客笔记
08-25 6255
文章目录前言问题描述 前言 此篇文章是我在B站学习时所做的笔记，大部分图片都是课件老师的PPT，方便复习用。此篇文章仅供学习参考。 提示：以下是本篇文章正文内容 问题描述
生产者消费者问题
weixin_33733810的博客
03-25 303
一、实验目的 学习生产者与消费者的运行基本原理，学习使用共享内存区，学习使用多进程，学会使用锁互斥访问对象。 二、实验内容 一个大小为3的缓冲区，初始为空 •2个生产者 –随机等待一段时间，往缓冲区添加数据， –若缓冲区已满，等待消费者取走数据后再添加 –重复6次 •3个消费者 –随机等待一段时间，从缓冲区读取数据 –若缓冲区为空，等待生产者添加数据后再读...
多线程面试题系列（10）：生产者消费者问题
weixin_34245082的博客
09-11 469
继经典线程同步问题之后，我们来看看生产者消费者问题及读者写者问题。生产者消费者问题是一个著名的线程同步问题，该问题描述如下： 有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个具有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，即不允许消费者到一个空...
生产者-消费者问题
Kelvin的博客
11-30 578
前言 也叫缓存绑定问题（bounded- buffer），是一个经典的、多进程同步问题。 生产者、消费者问题 1. 问题描述 ​ 有n个生产者和m个消费者，连接在一个有k个单位缓冲区的有界缓冲上。其中，生产者进程Producer_i和消费者进程Consumer_j都是并发进程，只要缓冲区未满，生产者Producer_i生产的产品就可投入缓冲区；只要缓冲区不空，消费者进程Consumer_j就可从...
转----秒杀多线程第十篇 生产者消费者问题
Joyfulmath，一个快乐的程序员
04-01 187
继经典线程同步问题之 后，我们来看看生产者消费者问题及读者写者问题。生产者消费者问题是一个著名的线程同步问题，该问题描述如下：有一个生产者在生产产品，这些产品将提供给 若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个具有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从 缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，即不允许消费者到一个空的
操作系统自学（十三）生产者消费者问题以及多生产者多消费者问题
weixin_44302602的博客
12-08 2723
生产者消费者问题 系统中有一组生产者进程和消费者进程，生产者进程每次生产一个产品放入缓冲区，消费者进程每次从缓冲区中取出一个产品使用 （产品为某种数据） 生产者消费者共享一个初始为空 大小为n的缓冲区 只有缓冲区没满的时候 生产者才能将产品放入缓冲区，否则必须等待 (同步关系 缓冲区满的时候，生产者要等待消费者取走产品) 只有缓冲区不空的时候 消费者才能从缓冲区中取出产品否则必须等待 （同步关系 缓冲区空的时候 消费者必须等待生产者放入产品） 缓冲区是临界资源 所以各进程必须互斥的访问 我们可以使用P,V
经典同步问题最易理解的解题思路（PV操作/操作系统/408）
Morizen的博客
04-30 3027
信号量是操作系统用来解决并发中的互斥和同步问题的一种方法，具体的原理在此不做赘述。本文将从题目出发一步步的对同步问题（生产者消费者问题，读者写者问题，哲学家进餐问题）进行理解，并将以王道上的一道例题来验证解题思路。此处仅战术pv操作的逻辑，逻辑与程序一致，可以自行对其进行转换。 一、生产者消费者问题 问题描述:一组生产者进程和一组消费者进程共享一个初始为空、大小为n的缓冲区，只有缓冲区没满时，生产者才能把消息放入缓冲区，否则必须等待;只有缓冲区不空时，消费者才能从中取出消息，否则必须等待。由于缓冲区是.
多线程4------＞多线程案例
qq_45704528的博客
03-23 947
目录一.生产者消费者问题二.单例模式三.阻塞式队列四.线程池 一.生产者消费者问题 示例： 面包店 10个生产者，每个每次生产3个 20个消费者，每个每次消费一个 进阶版需求 面包师傅每个最多生产30次，面包店每天生产10303=900个面包 消费者也不是一直消费。把900个面包消费完结束 隐藏信息：面包店每天生产面包的最大数量为900个 消费者把900个面包消费完结束 代码示例： /** * 面包店 * 10个生产者，每个每次生产3个 * 20个消费者，每个每次消费一个
工学操作系统期末复习.pptx
最新发布
11-14
经典的进程同步问题包括哲学家就餐问题、生产者消费者问题、读者写者问题等。线程作为轻量级进程，是现代操作系统中的重要概念，它可以提高系统资源的利用率和执行效率。 在第二章中，信号量机制的P、V操作是实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值