继经典线程同步问题之后，我们来看看生产者消费者问题及读者写者问题。生产者消费者问题是一个著名的线程同步问题，该问题描述如下：有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个具有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经放入产品的缓冲区中再次投放产品。

这个生产者消费者题目不仅常用于操作系统的课程设计，也常常在程序员和软件设计师考试中出现。并且在计算机考研的专业课考试中也是一个非常热门的问题。因此现在就针对这个问题进行详细深入的解答。

首先来简化问题，先假设生产者和消费者都只有一个，且缓冲区也只有一个。这样情况就简便多了。

第一．从缓冲区取出产品和向缓冲区投放产品必须是互斥进行的。可以用关键段和互斥量来完成。

第二．生产者要等待缓冲区为空，这样才可以投放产品，消费者要等待缓冲区不为空，这样才可以取出产品进行消费。并且由于有二个等待过程，所以要用二个事件或信号量来控制。

考虑这二点后，代码很容易写出来。另外为了美观起见，将消费者的输出颜色设置为彩色，有关如何在控制台下设置彩色输出请参阅《VC 控制台颜色设置》。

[cpp] view plaincopy
  1. //1生产者 1消费者 1缓冲区
  2. //使用二个事件，一个表示缓冲区空，一个表示缓冲区满。
  3. //再使用一个关键段来控制缓冲区的访问
  4. #include <stdio.h>
  5. #include <process.h>
  6. #include <windows.h>
  7. //设置控制台输出颜色
  8. BOOL SetConsoleColor(WORD wAttributes)
  9. {
  10. HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
  11. if (hConsole == INVALID_HANDLE_VALUE)
  12. return FALSE;
  13. return SetConsoleTextAttribute(hConsole, wAttributes);
  14. }
  15. const int END_PRODUCE_NUMBER = 10;   //生产产品个数
  16. int g_Buffer;                        //缓冲区
  17. //事件与关键段
  18. CRITICAL_SECTION g_cs;
  19. HANDLE g_hEventBufferEmpty, g_hEventBufferFull;
  20. //生产者线程函数
  21. unsigned int __stdcall ProducerThreadFun(PVOID pM)
  22. {
  23. for (int i = 1; i <= END_PRODUCE_NUMBER; i++)
  24. {
  25. //等待缓冲区为空
  26. WaitForSingleObject(g_hEventBufferEmpty, INFINITE);
  27. //互斥的访问缓冲区
  28. EnterCriticalSection(&g_cs);
  29. g_Buffer = i;
  30. printf("生产者将数据%d放入缓冲区\n", i);
  31. LeaveCriticalSection(&g_cs);
  32. //通知缓冲区有新数据了
  33. SetEvent(g_hEventBufferFull);
  34. }
  35. return 0;
  36. }
  37. //消费者线程函数
  38. unsigned int __stdcall ConsumerThreadFun(PVOID pM)
  39. {
  40. volatile bool flag = true;
  41. while (flag)
  42. {
  43. //等待缓冲区中有数据
  44. WaitForSingleObject(g_hEventBufferFull, INFINITE);
  45. //互斥的访问缓冲区
  46. EnterCriticalSection(&g_cs);
  47. SetConsoleColor(FOREGROUND_GREEN);
  48. printf("  消费者从缓冲区中取数据%d\n", g_Buffer);
  49. SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  50. if (g_Buffer == END_PRODUCE_NUMBER)
  51. flag = false;
  52. LeaveCriticalSection(&g_cs);
  53. //通知缓冲区已为空
  54. SetEvent(g_hEventBufferEmpty);
  55. Sleep(10); //some other work should to do
  56. }
  57. return 0;
  58. }
  59. int main()
  60. {
  61. printf("  生产者消费者问题   1生产者 1消费者 1缓冲区\n");
  62. printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");
  63. InitializeCriticalSection(&g_cs);
  64. //创建二个自动复位事件，一个表示缓冲区是否为空，另一个表示缓冲区是否已经处理
  65. g_hEventBufferEmpty = CreateEvent(NULL, FALSE, TRUE, NULL);
  66. g_hEventBufferFull = CreateEvent(NULL, FALSE, FALSE, NULL);
  67. const int THREADNUM = 2;
  68. HANDLE hThread[THREADNUM];
  69. hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);
  70. hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
  71. WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);
  72. CloseHandle(hThread[0]);
  73. CloseHandle(hThread[1]);
  74. //销毁事件和关键段
  75. CloseHandle(g_hEventBufferEmpty);
  76. CloseHandle(g_hEventBufferFull);
  77. DeleteCriticalSection(&g_cs);
  78. return 0;
  79. }

运行结果如下所示：

可以看出生产者与消费者已经是有序的工作了。

然后再对这个简单生产者消费者问题加大难度。将消费者改成2个，缓冲池改成拥有4个缓冲区的大缓冲池。

如何来思考了这个问题了？首先根据上面分析的二点，可以知道生产者和消费者由一个变成多个的影响不大，唯一要注意的是缓冲池变大了，回顾一下《秒杀多线程第八篇 经典线程同步 信号量Semaphore》中的信号量，不难得出用二个信号量就可以解决这种缓冲池有多个缓冲区的情况——用一个信号量A来记录为空的缓冲区个数，另一个信号量B记录非空的缓冲区个数，然后生产者等待信号量A，消费者等待信号量B就可以了。因此可以仿照上面的代码来实现复杂生产者消费者问题，示例代码如下：

[cpp] view plaincopy
  1. //1生产者 2消费者 4缓冲区
  2. #include <stdio.h>
  3. #include <process.h>
  4. #include <windows.h>
  5. //设置控制台输出颜色
  6. BOOL SetConsoleColor(WORD wAttributes)
  7. {
  8. HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
  9. if (hConsole == INVALID_HANDLE_VALUE)
  10. return FALSE;
  11. return SetConsoleTextAttribute(hConsole, wAttributes);
  12. }
  13. const int END_PRODUCE_NUMBER = 8;  //生产产品个数
  14. const int BUFFER_SIZE = 4;          //缓冲区个数
  15. int g_Buffer[BUFFER_SIZE];          //缓冲池
  16. int g_i, g_j;
  17. //信号量与关键段
  18. CRITICAL_SECTION g_cs;
  19. HANDLE g_hSemaphoreBufferEmpty, g_hSemaphoreBufferFull;
  20. //生产者线程函数
  21. unsigned int __stdcall ProducerThreadFun(PVOID pM)
  22. {
  23. for (int i = 1; i <= END_PRODUCE_NUMBER; i++)
  24. {
  25. //等待有空的缓冲区出现
  26. WaitForSingleObject(g_hSemaphoreBufferEmpty, INFINITE);
  27. //互斥的访问缓冲区
  28. EnterCriticalSection(&g_cs);
  29. g_Buffer[g_i] = i;
  30. printf("生产者在缓冲池第%d个缓冲区中投放数据%d\n", g_i, g_Buffer[g_i]);
  31. g_i = (g_i + 1) % BUFFER_SIZE;
  32. LeaveCriticalSection(&g_cs);
  33. //通知消费者有新数据了
  34. ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);
  35. }
  36. printf("生产者完成任务，线程结束运行\n");
  37. return 0;
  38. }
  39. //消费者线程函数
  40. unsigned int __stdcall ConsumerThreadFun(PVOID pM)
  41. {
  42. while (true)
  43. {
  44. //等待非空的缓冲区出现
  45. WaitForSingleObject(g_hSemaphoreBufferFull, INFINITE);
  46. //互斥的访问缓冲区
  47. EnterCriticalSection(&g_cs);
  48. SetConsoleColor(FOREGROUND_GREEN);
  49. printf("  编号为%d的消费者从缓冲池中第%d个缓冲区取出数据%d\n", GetCurrentThreadId(), g_j, g_Buffer[g_j]);
  50. SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  51. if (g_Buffer[g_j] == END_PRODUCE_NUMBER)//结束标志
  52. {
  53. LeaveCriticalSection(&g_cs);
  54. //通知其它消费者有新数据了(结束标志)
  55. ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);
  56. break;
  57. }
  58. g_j = (g_j + 1) % BUFFER_SIZE;
  59. LeaveCriticalSection(&g_cs);
  60. Sleep(50); //some other work to do
  61. ReleaseSemaphore(g_hSemaphoreBufferEmpty, 1, NULL);
  62. }
  63. SetConsoleColor(FOREGROUND_GREEN);
  64. printf("  编号为%d的消费者收到通知，线程结束运行\n", GetCurrentThreadId());
  65. SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  66. return 0;
  67. }
  68. int main()
  69. {
  70. printf("  生产者消费者问题   1生产者 2消费者 4缓冲区\n");
  71. printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");
  72. InitializeCriticalSection(&g_cs);
  73. //初始化信号量,一个记录有产品的缓冲区个数,另一个记录空缓冲区个数.
  74. g_hSemaphoreBufferEmpty = CreateSemaphore(NULL, 4, 4, NULL);
  75. g_hSemaphoreBufferFull  = CreateSemaphore(NULL, 0, 4, NULL);
  76. g_i = 0;
  77. g_j = 0;
  78. memset(g_Buffer, 0, sizeof(g_Buffer));
  79. const int THREADNUM = 3;
  80. HANDLE hThread[THREADNUM];
  81. //生产者线程
  82. hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);
  83. //消费者线程
  84. hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
  85. hThread[2] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
  86. WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);
  87. for (int i = 0; i < THREADNUM; i++)
  88. CloseHandle(hThread[i]);
  89. //销毁信号量和关键段
  90. CloseHandle(g_hSemaphoreBufferEmpty);
  91. CloseHandle(g_hSemaphoreBufferFull);
  92. DeleteCriticalSection(&g_cs);
  93. return 0;
  94. }

运行结果如下图所示：

输出结果证明各线程的同步和互斥已经完成了。

至此，生产者消费者问题已经圆满的解决了，下面作个总结：

1．首先要考虑生产者与消费者对缓冲区操作时的互斥。

2．不管生产者与消费者有多少个，缓冲池有多少个缓冲区。都只有二个同步过程——分别是生产者要等待有空缓冲区才能投放产品，消费者要等待有非空缓冲区才能去取产品。

下一篇《秒杀多线程第十一篇读者写者问题》将介绍另一个著名的同步问题——读者写者问题，欢迎大家再来参阅。

转载请标明出处，原文地址：http://blog.csdn.net/morewindows/article/details/7577591

如果觉得本文对您有帮助，请点击‘顶’支持一下，您的支持是我写作最大的动力，谢谢。

秒杀多线程第十篇 生产者消费者问题相关推荐

  1. 秒杀多线程第十篇 生产者消费者问题 （续）

    使用java 和semaphore实现的 ,多个生产者和多个消费者的问题. 1.使用Semaphore,Semaphore的大小设定为BUFFER_LENGTH.也就是同时最多有这么多线程来操作缓冲区 ...

  2. 秒杀多线程第十六篇 多线程十大经典案例之一 双线程读写队列数据

    本文配套程序下载地址为:http://download.csdn.net/detail/morewindows/5136035 转载请标明出处,原文地址:http://blog.csdn.net/mo ...

  3. 秒杀多线程第十二篇 多线程同步内功心法——PV操作上

    阅读本篇之前推荐阅读以下姊妹篇: <秒杀多线程第四篇一个经典的多线程同步问题> <秒杀多线程第五篇经典线程同步关键段CS> <秒杀多线程第六篇经典线程同步事件Event& ...

  4. 秒杀多线程第十一篇 读者写者问题

    与上一篇<秒杀多线程第十篇 生产者消费者问题>的生产者消费者问题一样,读者写者也是一个非常著名的同步问题.读者写者问题描述非常简单,有一个写者很多读者,多个读者可以同时读文件,但写者在写文 ...

  5. 秒杀多线程第八篇 经典线程同步 信号量Semaphore

    阅读本篇之前推荐阅读以下姊妹篇: <秒杀多线程第四篇一个经典的多线程同步问题> <秒杀多线程第五篇经典线程同步关键段CS> <秒杀多线程第六篇经典线程同步事件Event& ...

  6. 秒杀多线程第十一篇---读者写者问题

    与上一篇<秒杀多线程第十篇 生产者消费者问题>的生产者消费者问题一样,读者写者也是一个非常著名的同步问题.读者写者问题描述非常简单,有一个写者很多读者,多个读者可以同时读文件,但写者在写文 ...

  7. 秒杀多线程第十五篇 关键段,事件,互斥量,信号量的“遗弃”问题

    秒杀多线程第十五篇 关键段,事件,互斥量,信号量的"遗弃"问题 在<秒杀多线程第九篇 经典线程同步总结 关键段 事件 互斥量 信号量>中对经典多线程同步互斥问题进行了回 ...

  8. 秒杀多线程第十四篇 读者写者问题继 读写锁SRWLock

    在<秒杀多线程第十一篇读者写者问题>文章中我们使用事件和一个记录读者个数的变量来解决读者写者问题.问题虽然得到了解决,但代码有点复杂.本篇将介绍一种新方法--读写锁SRWLock来解决这一 ...

  9. 秒杀多线程第六篇 经典线程同步 事件Event

    阅读本篇之前推荐阅读以下姊妹篇: <秒杀多线程第四篇 一个经典的多线程同步问题> <秒杀多线程第五篇 经典线程同步关键段CS> 上一篇中使用关键段来解决经典的多线程同步互斥问题 ...

最新文章

  1. 漫画：设计模式之 “工厂模式”
  2. linux和aix设置时间
  3. MySQL 遇到的问题
  4. 外媒称Windows 10是一辆“广告大巴车”
  5. ASP.NET MVC 入门7、Hellper与数据的提交与绑定
  6. react native (一)
  7. promise链式调用_这一次，彻底弄懂 Promise
  8. 《设计模式》模板设计方法——面条非常香
  9. python爬取qq音乐评论_爬虫：QQ音乐评论
  10. 【IDEA】报错：Warning:java: 源值1.5已过时, 将在未来所有发行版中删除
  11. TableViewCell分割线消失的问题
  12. Atitit 头像文件上传功能实现目录1. 上传文件原理 11.1. 界面ui 11.2. 预览实现 21.3. 保存头像文件php 21.4. 保存文件nodejs java 32
  13. 博弈论总结 四大博弈模型 SG函数
  14. linux kernel pwn学习之堆漏洞利用+bypass smap、smep
  15. 学习状态通道，Part-1：支付通道
  16. 17.12.2B组总结
  17. R语言学习：方差分析
  18. 多地“摇号购房” 开发商迎来了良机？
  19. 华为OD机试 - 日志首次上报最多积分
  20. 《计算机网络技术》第一章课后习题答案（全）

热门文章

  1. File类判断功能的方法
  2. php 数组插入键和值,php数组中键和值的关系
  3. html语言 input button,Html-button和input的区别
  4. DelayQueue源码
  5. linux java maven项目_Java maven项目在window下运行正常，部署到Linux环境中启动报错，是由什么引起的？...
  6. Ubuntu 华为开源镜像站 Mirror
  7. Handler 源码解析(Java 层)
  8. 云计算数据管理的4个关键因素
  9. springboot+mybatis+thymeleaf项目搭建及前后端交互
  10. 小技巧：with用法 pycharm控制台输出带颜色的文字 打印进度条的