Windowns操作系统：生产者消费者模型

任务：有10个生产者 10 个消费者

需要总共生产100个产品

每生产一件消费一件

生产100件生产者退出

消费100件消费者退出

分析：

分别创建10个生产者 10个消费者线程

生产者线程函数：

生产产品，全局变量++，最开始10个消费者处于阻塞

生产者每生产一个，释放一个信号

消费者每收到一个信号就消费一个产品

因为基于有限制个数去执行任务 所以我们采用信号量

 

下面请看详细代码：

#include <QCoreApplication>
#include <windows.h>
#include <queue>
#include <process.h>
#include <iostream>
using namespace std;


CRITICAL_SECTION m_s;
HANDLE hSemaphore = CreateSemaphoreA(0,0,100,0);
HANDLE hMudex = CreateMutexA(0,0,0);


int g_Num = 0;
std::queue<int> que;
unsigned __stdcall ProThreadProc(void* lpvoid)
{
    while(1)
    {
       WaitForSingleObject(hMudex,INFINITE);
        if(g_Num >= 100)
            break;
        g_Num++;
        que.push(g_Num);
        ReleaseMutex(hMudex);
        ReleaseSemaphore(hSemaphore,1,0);
    }
    return 0;
}
unsigned __stdcall CusThreadProc(void* lpvoid)
{
    while(1)
    {
      WaitForSingleObject(hSemaphore,INFINITE);

        WaitForSingleObject(hMudex,INFINITE);
        if(que.empty())
            break;
        cout << que.front() << endl;
        que.pop();
        ReleaseSemaphore(hSemaphore,1,0);
    }
    return 0;
}
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    InitializeCriticalSection(&m_s);
    //创建10个生产者线程
    for(int i = 0; i < 10; i++)
    {
        HANDLE hProThread = (HANDLE)_beginthreadex(0,0,&ProThreadProc,0,0,0);
        if(!hProThread)
        {
            CloseHandle(hProThread);
            hProThread = nullptr;
        }
    }
    //创建10个消费者线程
    for(int i = 0; i < 10; i++)
    {
        HANDLE hCusThread = (HANDLE)_beginthreadex(0,0,&CusThreadProc,0,0,0);
        if(!hCusThread)
        {
            CloseHandle(hCusThread);
            hCusThread = nullptr;
        }
    }
    return a.exec();
}

 输出：