c++ Windows下多线程编程，使用信号量实现生产者与消费者

常用函数：

HANDLE WINAPI CreateSemaphore(               
  _In_opt_  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes
  _In_      LONG lInitialCount,
  _In_      LONG lMaximumCount,
  _In_opt_  LPCTSTR lpName
);
第一个参数：安全属性，如果为NULL则是默认安全属性
第二个参数：信号量的初始值，要>=0且<=第三个参数
第三个参数：信号量的最大值
第四个参数：信号量的名称

返回值：指向信号量的句柄，如果创建的信号量和已有的信号量重名，那么返回已经存在的信号量句柄

DWORD WaitForSingleObject(  

 HANDLE hHandle,   

 DWORD dwMilliseconds

);

第一个参数：等待对象的 handle（代表一个核心对象）。

第二个参数：等待的最长时间。时间终了，即使 handle尚未成为激发状态，此函数也要返回。此值可以是0（代表立刻返回），也可以是 INFINITE代表无穷等待。

BOOL WINAPI ReleaseSemaphore(             
  _In_       HANDLE hSemaphore,
  _In_       LONG lReleaseCount,
  _Out_opt_  LPLONG lpPreviousCount
);
第一个参数：信号量句柄
第二个参数：释放后，信号量增加的数目
第三个参数：信号量增加前的值存放的地址，如果不需要则为NULL
返回值：释放是否成功

生产者与消费者的实现:

扫描二维码关注公众号，回复： 2345044 查看本文章

#include<string>
 #include<iostream>
 #include<process.h>
 #include<windows.h>
 using namespace std;
 HANDLE empty,full; //同步信号量 缓冲池的剩余 缓冲池中的产品个数 生产者与消费者同步
 HANDLE mutex;//互斥信号量，生产者与生产者互斥，消费者与消费者互斥
 int buf_max;       //缓冲池大小
 int product=0;     //产品数量
//生产者线程
unsigned __stdcall threadProducer(void *)
{
    for(int i = 0; i < 10; i++){
        WaitForSingleObject(empty, INFINITE);//等待同步信号量empty
        WaitForSingleObject(mutex, INFINITE);//等待互斥信号量mutex
        product++;
        cout<<"生产者生产了一个产品！当前产品数量:"<<product<<endl<<endl;
        Sleep(100);
        ReleaseSemaphore(mutex, 1, NULL);//释放互斥信号量mutex
        ReleaseSemaphore(full, 1, NULL);//释放同步信号量full
    }
    return 1;
}
//消费者线程
unsigned __stdcall threadConsumer(void *)
{
    for(int i = 0; i < 10; i++){
        WaitForSingleObject(full, INFINITE);//等待同步信号量full
        WaitForSingleObject(mutex, INFINITE);//等待互斥信号量mutex
        product--;
        cout<<"消费者消费了一个产品！当前产品数量:"<<product<<endl<<endl;
        Sleep(100);
        ReleaseSemaphore(mutex, 1, NULL);//释放互斥信号量mutex
        ReleaseSemaphore(empty, 1, NULL);//释放信号量
    }
    return 2;
}
 
int main()
{
    bool flag=false;
    while(!flag)
    {
    cout<<"请输入缓冲池大小(大于0):"<<endl;
    cin>>buf_max;
    if(buf_max<=0);
    else flag=true;
    }
    //创建信号量
    empty = CreateSemaphore(NULL, buf_max, buf_max, NULL);//初值为缓冲池大小，最大为缓冲池大小
    full = CreateSemaphore(NULL, 0, buf_max, NULL);       //初值为0，最大为缓冲池大小
    mutex = CreateSemaphore(NULL,1,1,NULL);               //初值为1,最大为1
    HANDLE hth1, hth2;                                    //线程句柄
 
    //创建线程
    hth1 = (HANDLE)_beginthreadex(NULL, 0, threadProducer, NULL, 0, NULL);//生产者线程
    hth2 = (HANDLE)_beginthreadex(NULL, 0, threadConsumer, NULL, 0, NULL);//消费者线程
 
    //等待子线程结束
    WaitForSingleObject(hth1, INFINITE);
    WaitForSingleObject(hth2, INFINITE);
 
    //一定要记得关闭句柄
    CloseHandle(hth1);
    CloseHandle(hth2);
    CloseHandle(empty);
    CloseHandle(full);
    CloseHandle(mutex);
}