zoukankan      html  css  js  c++  java

  • 生产者消费者问题

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

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

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

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

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

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

    [cpp] view plain copy
     
    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放入缓冲区 ", 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 ", 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缓冲区 ");  
    67.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) -- ");  
    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 plain copy
     

    #include<stdio.h>
    #include<process.h>
    #include<Windows.h>

    const int Products_Num = 8;
    const int BUFFER_SIZE = 4;
    int Buffer[BUFFER_SIZE];
    bool g_bProductorOver = false;
    CRITICAL_SECTION g_cs;
    HANDLE g_hThreadSemaforphoreEmpty, g_hThreadSemaforphoreFull;

    int g_i, g_j;
    //控制台颜色调配
    BOOL SetConsoleColor(WORD wAttributes)
    {
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hConsole == INVALID_HANDLE_VALUE)
    return FALSE;
    return SetConsoleTextAttribute(hConsole, wAttributes);
    }

    unsigned int _stdcall ProducerThreadFun(PVOID pM)
    {
    for (int i = 1; i <=Products_Num; i++)
    {
    WaitForSingleObject(g_hThreadSemaforphoreEmpty, INFINITE);

    EnterCriticalSection(&g_cs);
    Buffer[g_i] = i;
    printf("生产者放入%d缓冲区的数据为%d ", g_i, Buffer[g_i]);
    g_i = (g_i + 1) % BUFFER_SIZE;
    LeaveCriticalSection(&g_cs);
    ReleaseSemaphore(g_hThreadSemaforphoreFull, 1, NULL);
    }
    printf("生产者放入数据完成 ");
    return 0;
    }
    unsigned int _stdcall CustomerThreadFun(PVOID pM)
    {
    // volatile bool flag = true;
    while (true)
    {
    WaitForSingleObject(g_hThreadSemaforphoreFull, INFINITE);
    EnterCriticalSection(&g_cs);
    if (g_bProductorOver==true)
    {
    // flag = false;
    break; //跳出到哪里去了
    }
    SetConsoleColor(FOREGROUND_RED);
    printf("编号为%d的消费者从缓冲池中第%d个缓冲区取出数据%d ", GetCurrentThreadId(), g_j, Buffer[g_j]);
    SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    if (Buffer[g_j] == Products_Num)
    /*当缓冲池里就剩一个资源的时候，两个消费线程都会去消费这个资源。
    可是当A线程消费完这个资源后， 为了不让B陷入无尽的等待（因为生产线程已经结束），
    所以在A消费之后凭空释放了一个资源，导致同一个资源被消费两次*/
    {
    ReleaseSemaphore(g_hThreadSemaforphoreEmpty, 1, NULL);
    g_bProductorOver = true;
    // flag = false;
    LeaveCriticalSection(&g_cs);

    break;
    }
    g_j = (g_j + 1) % BUFFER_SIZE;
    LeaveCriticalSection(&g_cs);
    Sleep(50);
    ReleaseSemaphore(g_hThreadSemaforphoreEmpty, 1, NULL);


    }
    SetConsoleColor(FOREGROUND_GREEN);
    printf("消费者取出数据完成 ");
    SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);

    return 0;
    }

    int main()
    {
    InitializeCriticalSection(&g_cs);
    g_hThreadSemaforphoreEmpty = CreateSemaphore(NULL, 4, 4, NULL);
    g_hThreadSemaforphoreFull = CreateSemaphore(NULL, 0, 4, NULL);
    g_i = 0;
    g_j = 0;
    memset(Buffer, 0, sizeof(Buffer));

    const int THREADNUM = 3;
    HANDLE hThread[THREADNUM];
    hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);
    hThread[1] = (HANDLE)_beginthreadex(NULL, 0, CustomerThreadFun, NULL, 0, NULL);
    hThread[2] = (HANDLE)_beginthreadex(NULL, 0, CustomerThreadFun, NULL, 0, NULL);
    //hThread[3] = (HANDLE)_beginthreadex(NULL, 0, CustomerThreadFun, NULL, 0, NULL);
    //hThread[4] = (HANDLE)_beginthreadex(NULL, 0, CustomerThreadFun, NULL, 0, NULL);
    WaitForMultipleObjects(THREADNUM, hThread, TRUE, 1000);

    for (int i = 0; i < THREADNUM; i++)
    CloseHandle(hThread[i]);

    //销毁信号量和关键段
    CloseHandle(g_hThreadSemaforphoreEmpty);
    CloseHandle(g_hThreadSemaforphoreFull);
    DeleteCriticalSection(&g_cs);
    system("pause");
    return 0;
    }

    运行结果如下图所示：

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

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

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

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

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

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

    如果觉得本文对您有帮助，请点击‘顶’支持一下，您的支持是我写作最大的动力，谢谢。
  • 相关阅读:
    如何在SQL/400中计算两日期间的天数
    委托、事件与Observer设计模式
    C# 杂项
    泛型学习（二）
    委托
    操作符重载 (operator)
    一个解决方案多个项目
    将方法绑定到委托
    事件
    密封方法 密封类（sealed）
  • 原文地址：https://www.cnblogs.com/zsq1993/p/5998220.html
Copyright © 2011-2022 走看看