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

    习题:假设

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

    初始物品100个

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

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

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

    直到这样交互100次

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

    消费者任务  物品--;

    生产者任务  物品++;

    这里有个条件

    1.

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

    2.

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

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

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

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

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

    如此往复

    完整代码如下

    生产者消费者类的声明

    1. #ifndef CREATER_H
    2. #define CREATER_H
    3. #include
    4. #include
    5. #include
    6.  
    7. class CreaterConsumer
    8. {
    9. private:
    10.     //生产者句柄
    11.     HANDLE m_Create;
    12.     //消费者句柄
    13.     HANDLE m_Consumer;
    14.     //生产者线程链表
    15.     std::list m_myCreaterlist;
    16.     //消费者线程链表
    17.     std::list m_myConsumerlist;
    18.     //产品数量
    19.     long product;
    20.     //生产者互斥量
    21.     HANDLE m_MutexCreater;
    22.     //消费者互斥量
    23.     HANDLE m_MutexConsumer;
    24. public:
    25.     //记录交互次数
    26.     long nCount;
    27. public:
    28.     CreaterConsumer();
    29.     ~CreaterConsumer();
    30.     //创建生产者线程池
    31.     bool CreateThreadPool();
    32.     //创建消费者线程池
    33.     bool ConsumerThreadPool();
    34.     //销毁生产者线程池
    35.     void DeleteCreaterThreadPool();
    36.     //销毁消费者线程池
    37.     void DeleteConsumerThreadPool();
    38.     //生产者线程函数
    39.     static DWORD WINAPI CreateThreadProc(LPVOID lpvoid);
    40.     //消费者线程函数
    41.     static DWORD WINAPI ConsumerThreadProc(LPVOID lpvoid);
    42. };
    43.  
    44. #endif // CREATER_H

    生产者消费者类的的定义

    1. #include "creater.h"
    2. #include
    3. using namespace std;
    4. CreaterConsumer::CreaterConsumer()
    5. {
    6.      m_Create=NULL;
    7.      m_Consumer=NULL;
    8.      product=100;
    9.      m_MutexCreater=CreateMutex(0,0,0);
    10.      m_MutexConsumer=CreateMutex(0,1,0);//开始先让消费者启动交互
    11.      nCount=0;
    12.  
    13. }
    14.  
    15. CreaterConsumer::~CreaterConsumer()
    16. {
    17.  
    18. }
    19. bool CreaterConsumer::CreateThreadPool()
    20. {
    21.     //创建十个线程到生产者线程列表中去
    22.     for(int  i=0;i<10;i++)
    23.     {
    24.         m_Create=CreateThread(0,0,&CreateThreadProc,this,0,0);
    25.         if(m_Create)
    26.         {
    27.             m_myCreaterlist.push_back(m_Create);
    28.         }
    29.     }
    30.  
    31.  
    32. }
    33.  
    34. bool CreaterConsumer::ConsumerThreadPool()
    35. {
    36.     //创建十个线程到消费者线程列表中去
    37.     for(int  i=0;i<10;i++)
    38.     {
    39.         m_Consumer=CreateThread(0,0,&CreateThreadProc,this,0,0);
    40.         if(m_Consumer)
    41.         {
    42.             m_myConsumerlist.push_back(m_Consumer);
    43.         }
    44.     }
    45. }
    46.  
    47. DWORD WINAPI CreaterConsumer::CreateThreadProc(LPVOID lpvoid)
    48. {
    49.     CreaterConsumer* pthis=(CreaterConsumer*)lpvoid;
    50.     while(1)
    51.     {
    52.         //当前交互次数小于100
    53.         if(pthis->nCount<100)
    54.         {
    55.             WaitForSingleObject(pthis->m_MutexCreater,INFINITE);
    56.             //当交互次数为 例如:99 时 进来了多个线程
    57.             //如果一个交互次数为99 的线程执行完 交互次数变为100 应该不继续执行
    58.             //但是剩下的进来的这些线程不会出去 会继续执行 交互次数就会大于100 所以加了一个筛选 if(pthis->nCount>=100)
    59.  
    60.             if(pthis->nCount>=100)
    61.             {
    62.                 //如果此时交互次数>=100  剩下的进来的线程不会继续执行  而是会被筛选出去
    63.                 ReleaseMutex( pthis->m_MutexConsumer);
    64.                 continue;
    65.             }
    66.             //pthis->product++;
    67.             //物品数++
    68.             InterlockedIncrement(&pthis->product);
    69.             //交互次数++
    70.             InterlockedIncrement(&pthis->nCount);
    71.             //打印交互次数
    72.             cout<nCount<
    73.             //释放消费者信号
    74.             ReleaseMutex(pthis->m_MutexConsumer);
    75.         }
    76.  
    77.     }
    78.  
    79. }
    80.  
    81. DWORD WINAPI CreaterConsumer::ConsumerThreadProc(LPVOID lpvoid)
    82. {
    83.     CreaterConsumer* pthis=(CreaterConsumer*)lpvoid;
    84.     while(1)
    85.     {
    86.         if(pthis->nCount<100)
    87.         {
    88.             WaitForSingleObject(pthis->m_MutexConsumer,INFINITE);
    89.             if(pthis->nCount>=100)
    90.             {
    91.                 ReleaseMutex( pthis->m_MutexCreater);
    92.                 continue;
    93.             }
    94.             //pthis->product--;
    95.             //物品数--;
    96.             InterlockedDecrement(&pthis->product);
    97.             //释放生产者信号
    98.             ReleaseMutex(pthis->m_MutexCreater);
    99.         }
    100.  
    101.  
    102.  
    103.     }
    104.  
    105.  
    106.  
    107. }
    108.  
    109.  
    110. void CreaterConsumer::DeleteCreaterThreadPool()
    111. {
    112.     //遍历生产者列表
    113.     auto ite= m_myCreaterlist.begin();
    114.     //将生产者列表的每一项都删除
    115.     while(ite!=m_myCreaterlist.end())
    116.     {
    117.         delete *ite;
    118.         ite++;
    119.     }
    120.     //清空列表
    121.     m_myCreaterlist.clear();
    122.  
    123.     //释放生产者线程句柄
    124.     if(m_Create)
    125.     {
    126.         CloseHandle(m_Create);
    127.         m_Create=NULL;
    128.     }
    129.     //释放生产者互斥量
    130.     if(m_MutexCreater)
    131.     {
    132.          CloseHandle(m_MutexCreater);
    133.          m_MutexCreater=NULL;
    134.     }
    135. }
    136.  
    137. void CreaterConsumer::DeleteConsumerThreadPool()
    138. {
    139.     //遍历并删除消费者列表的每一项
    140.     auto ite= m_myConsumerlist.begin();
    141.     while(ite!=m_myConsumerlist.end())
    142.     {
    143.         delete *ite;
    144.         ite++;
    145.     }
    146.     //清空消费者列表
    147.     m_myConsumerlist.clear();
    148.  
    149.     //释放消费者线程句柄
    150.     if(m_Consumer)
    151.     {
    152.         CloseHandle(m_Consumer);
    153.         m_Consumer=NULL;
    154.     }
    155.     //释放消费者互斥量
    156.     if(m_MutexConsumer)
    157.     {
    158.          CloseHandle(m_MutexConsumer);
    159.          m_MutexConsumer=NULL;
    160.     }
    161.  
    162. }

    主函数

    1. #include "creater.h"
    2. #include
    3. using namespace std;
    4. CreaterConsumer::CreaterConsumer()
    5. {
    6.      m_Create=NULL;
    7.      m_Consumer=NULL;
    8.      product=100;
    9.      m_MutexCreater=CreateMutex(0,0,0);
    10.      m_MutexConsumer=CreateMutex(0,1,0);
    11.      nCount=0;
    12.  
    13. }
    14.  
    15. CreaterConsumer::~CreaterConsumer()
    16. {
    17.  
    18. }
    19. bool CreaterConsumer::CreateThreadPool()
    20. {
    21.     //创建十个线程到线程列表中去
    22.     for(int  i=0;i<10;i++)
    23.     {
    24.         m_Create=CreateThread(0,0,&CreateThreadProc,this,0,0);
    25.         if(m_Create)
    26.         {
    27.             m_myCreaterlist.push_back(m_Create);
    28.         }
    29.     }
    30.  
    31.  
    32. }
    33.  
    34. bool CreaterConsumer::ConsumerThreadPool()
    35. {
    36.     //创建十个线程到线程列表中去
    37.     for(int  i=0;i<10;i++)
    38.     {
    39.         m_Consumer=CreateThread(0,0,&CreateThreadProc,this,0,0);
    40.         if(m_Consumer)
    41.         {
    42.             m_myConsumerlist.push_back(m_Consumer);
    43.         }
    44.     }
    45. }
    46.  
    47. DWORD WINAPI CreaterConsumer::CreateThreadProc(LPVOID lpvoid)
    48. {
    49.     CreaterConsumer* pthis=(CreaterConsumer*)lpvoid;
    50.     while(1)
    51.     {
    52.         if(pthis->nCount<100)
    53.         {
    54.             WaitForSingleObject(pthis->m_MutexCreater,INFINITE);
    55.             if(pthis->nCount>=100)
    56.             {
    57.                 ReleaseMutex( pthis->m_MutexConsumer);
    58.                 continue;
    59.             }
    60.             //pthis->product++;
    61.             InterlockedIncrement(&pthis->product);
    62.             InterlockedIncrement(&pthis->nCount);
    63.             cout<nCount<
    64.             ReleaseMutex(pthis->m_MutexConsumer);
    65.         }
    66.  
    67.     }
    68.  
    69. }
    70.  
    71. DWORD WINAPI CreaterConsumer::ConsumerThreadProc(LPVOID lpvoid)
    72. {
    73.     CreaterConsumer* pthis=(CreaterConsumer*)lpvoid;
    74.     while(1)
    75.     {
    76.         if(pthis->nCount<100)
    77.         {
    78.             WaitForSingleObject(pthis->m_MutexConsumer,INFINITE);
    79.             if(pthis->nCount>=100)
    80.             {
    81.                 ReleaseMutex( pthis->m_MutexCreater);
    82.                 continue;
    83.             }
    84.             //pthis->product--;
    85.             InterlockedDecrement(&pthis->product);
    86.             ReleaseMutex(pthis->m_MutexCreater);
    87.         }
    88.  
    89.  
    90.  
    91.     }
    92.  
    93.  
    94.  
    95. }
    96.  
    97.  
    98. void CreaterConsumer::DeleteCreaterThreadPool()
    99. {
    100.     auto ite= m_myCreaterlist.begin();
    101.     while(ite!=m_myCreaterlist.end())
    102.     {
    103.         delete *ite;
    104.         ite++;
    105.     }
    106.     m_myCreaterlist.clear();
    107.  
    108.     if(m_Create)
    109.     {
    110.         CloseHandle(m_Create);
    111.         m_Create=NULL;
    112.     }
    113.     if(m_MutexCreater)
    114.     {
    115.          CloseHandle(m_MutexCreater);
    116.          m_MutexCreater=NULL;
    117.     }
    118. }
    119.  
    120. void CreaterConsumer::DeleteConsumerThreadPool()
    121. {
    122.     auto ite= m_myConsumerlist.begin();
    123.     while(ite!=m_myConsumerlist.end())
    124.     {
    125.         delete *ite;
    126.         ite++;
    127.     }
    128.  
    129.     if(m_Consumer)
    130.     {
    131.         CloseHandle(m_Consumer);
    132.         m_Consumer=NULL;
    133.     }
    134.     if(m_MutexConsumer)
    135.     {
    136.          CloseHandle(m_MutexConsumer);
    137.          m_MutexConsumer=NULL;
    138.     }
    139.  
    140. }

    执行结果

    交互次数为100 

  • 相关阅读:
    Pyhon中利用GM(1,1)和ARIMA模型对卫星DCB值进行预测
    极简的MapReduce实现
    02|一条MySQL更新语句是如何执行的
    @Transactional 的使用
    小谈设计模式（6）—依赖倒转原则
    安全工具--- rengine安装---资产侦查漏洞扫描
    第十四届蓝桥杯模拟赛（第二期）——C语言版
    Web请求与响应（SpringBoot）
    2023数学建模国赛选题建议及BC题思路
    Today‘s web RPC案例
  • 原文地址：https://blog.csdn.net/van9527/article/details/126224488