转----秒杀多线程第十篇 生产者消费者问题

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

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

 

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

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

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

    考虑这二点后，代码很容易写出来。另外为了美观起见，将消费者的输出颜色设置为彩色，有关如何在控制台下设置彩色输出请参阅《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.         //互斥的访问缓冲区  
  29.         EnterCriticalSection(&g_cs);  
  30.         g_Buffer = i;  
  31.         printf("生产者将数据%d放入缓冲区\n", i);  
  32.         LeaveCriticalSection(&g_cs);  
  33.           
  34.         //通知缓冲区有新数据了  
  35.         SetEvent(g_hEventBufferFull);  
  36.     }  
  37.     return 0;  
  38. }  
  39. //消费者线程函数  
  40. unsigned int __stdcall ConsumerThreadFun(PVOID pM)  
  41. {  
  42.     volatile bool flag = true;  
  43.     while (flag)  
  44.     {  
  45.         //等待缓冲区中有数据  
  46.         WaitForSingleObject(g_hEventBufferFull, INFINITE);  
  47.           
  48.         //互斥的访问缓冲区  
  49.         EnterCriticalSection(&g_cs);  
  50.         SetConsoleColor(FOREGROUND_GREEN);  
  51.         printf("  消费者从缓冲区中取数据%d\n", g_Buffer);  
  52.         SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);  
  53.         if (g_Buffer == END_PRODUCE_NUMBER)  
  54.             flag = false;  
  55.         LeaveCriticalSection(&g_cs);  
  56.           
  57.         //通知缓冲区已为空  
  58.         SetEvent(g_hEventBufferEmpty);  
  59.   
  60.         Sleep(10); //some other work should to do  
  61.     }  
  62.     return 0;  
  63. }  
  64. int main()  
  65. {  
  66.     printf("  生产者消费者问题   1生产者 1消费者 1缓冲区\n");  
  67.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
  68.   
  69.     InitializeCriticalSection(&g_cs);  
  70.     //创建二个自动复位事件，一个表示缓冲区是否为空，另一个表示缓冲区是否已经处理  
  71.     g_hEventBufferEmpty = CreateEvent(NULL, FALSE, TRUE, NULL);  
  72.     g_hEventBufferFull = CreateEvent(NULL, FALSE, FALSE, NULL);  
  73.       
  74.     const int THREADNUM = 2;  
  75.     HANDLE hThread[THREADNUM];  
  76.       
  77.     hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);  
  78.     hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);  
  79.     WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);  
  80.     CloseHandle(hThread[0]);  
  81.     CloseHandle(hThread[1]);  
  82.       
  83.     //销毁事件和关键段  
  84.     CloseHandle(g_hEventBufferEmpty);  
  85.     CloseHandle(g_hEventBufferFull);  
  86.     DeleteCriticalSection(&g_cs);  
  87.     return 0;  
  88. }  

运行结果如下所示：

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

 

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

运行结果如下图所示：

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

 

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

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

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

 

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

 

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

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

posted on 2014-11-12 10:14  Joyfulmath  阅读(286)  评论(0)  编辑  收藏  举报

导航