C++ 信号量内核对象

信号量内核对象

      信号量用来对资源进行计数。它包含两个32位值，一个表示能够使用的最大资源数量，一个表示当前可用的资源数量。

      信号量的使用规则如下：

1.       如果当前资源数量大于0，发出信号量信号

2.       如果当前资源数量是0，不发出信号量信号

3.       不允许当前资源数量为负值

4.       当前资源数量不能大于最大信号数量

通过CreateSemaphore创建。ReleaseSemaphore来释放资源，从而使当前资源数量增加。

当调用等待函数时，它会检查信号量的当前资源数量。如果它的值大于0，那么计数器减1，调用线程处于可调度状态。如果当前资源是0，则调用函数的线程进入等待状态。当另一个线程对信号量的当前资源通过ReleaseSemaphore进行递增时，系统会记住该等待线程，并将其变为可调度状态。

当有多个资源共访问时，经常使用信号量内核对象。

其成功等待副作用是当前资源数量减1。

应用场景：

例子，需要处理的数据个数为n个，处理数据的线程个数为m个，m < n,那么我们就可设置一个信号量，设置其最大资源数为m个，这样就可以尽可能的使用多线程并发处理，提高速率。如果使用信号量，则同时只能有一个线程运行。

 

//头文件
#include <windows.h>

//创建信号量API
HANDLE WINAPI CreateSemaphore(
 _In_opt_ LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,//指向SECURITY_ATTRIBUTES的指针;
 _In_     LONG                  lInitialCount,          //信号量对象的初始值；
 _In_     LONG                  lMaximumCount,  //信号量对象的最大值，这个值必须大于0;
 _In_opt_ LPCTSTR               lpName                 //信号量对象的名称；
);

//等待信号量API
DWORD WINAPI WaitForSingleObject(
  _In_ HANDLE hHandle,          //信号量对象句柄
  _In_ DWORD  dwMilliseconds    //等待信号量时间，INFINET代表永久等待；
);
返回值：
WAIT_ABANDONED(0x00000080L) 表示拥有信号量的线程再终止前未释放该信号量；
WAIT_OBJECT_0(0x00000000L)  表示等到了信号量；
WAIT_TIMEOUT(0x00000102L)   表示等待超时；
WAIT_FAILED((DWORD)0xFFFFFFFF)  表示该函数执行失败，用GetLastError()得到错误码；  

//释放信号量句柄
BOOL WINAPI ReleaseSemaphore(
  _In_      HANDLE hSemaphore,         //信号量对象句柄；
  _In_      LONG   lReleaseCount,      //信号量释放的值，必须大于0；
  _Out_opt_ LPLONG lpPreviousCount     //前一次信号量值的指针，不需要可置为空；
);
返回值：成功返回非0；

示例：

// threadtest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
// 使用信号量，同步线程
#include <iostream>
#include <windows.h>
#include <process.h>
#include <stdio.h>
using namespace std;
HANDLE g_seamaphore = nullptr;

unsigned int __stdcall fun1(LPVOID lpParamter)
{
	int iRunTime = 0;
	// 执行100次跳出
	while (iRunTime++ < 100)
	{
		WaitForSingleObject(g_seamaphore,INFINITE);
		cout << "fun1 is running!" <<iRunTime<< endl;
		ReleaseSemaphore(g_seamaphore,1,nullptr);
		Sleep(1);
	}
	return 0;
}
unsigned int __stdcall fun2(LPVOID lpParamter)
{
	int iRunTime = 0;
	// 执行100次跳出
	while (iRunTime++ < 100)
	{
		WaitForSingleObject(g_seamaphore, INFINITE);
		cout << "fun2 is running!" << iRunTime << endl;
		ReleaseSemaphore(g_seamaphore, 1, nullptr);
		Sleep(1);
	}
	return 0;
}
unsigned int __stdcall fun3(LPVOID lpParamter)
{
	int iRunTime = 0;
	// 执行100次跳出
	while (iRunTime++ < 100)
	{
		WaitForSingleObject(g_seamaphore, INFINITE);
		cout << "fun3 is running!" << iRunTime << endl;
		ReleaseSemaphore(g_seamaphore, 1, nullptr);
		Sleep(1);
	}
	return 0;
}
int main()
{
	g_seamaphore = CreateSemaphore(nullptr,
		3, 3, nullptr);
	HANDLE hThread[3] = { 0 };
	hThread[0] = (HANDLE)_beginthreadex(nullptr, 0, fun1, nullptr, 0, nullptr);
	hThread[1] = (HANDLE)_beginthreadex(nullptr, 0, fun2, nullptr, 0, nullptr);
	hThread[2] = (HANDLE)_beginthreadex(nullptr, 0, fun3, nullptr, 0, nullptr);
	getchar();
    for (int i = 0; i < 3; i++)
		CloseHandle(hThread[i]);
	return 0;
}