C++創建信號量 CreateSemaphore

一、定義

　Semaphore也是一個線程同步的輔助類，可以維護當前訪問自身的線程個數，並提供了同步機制。使用Semaphore可以控制同時訪問資源的線程個數，例如，實現一個文件允許的併發訪問數。

1.創建或打開命名或未命名的信號量對象。

HANDLE CreateSemaphore(
  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,  // SD
  LONG lInitialCount,                          // initial count
  LONG lMaximumCount,                          // maximum count
  LPCTSTR lpName                           // object name
)

參數說明：

 lpSemaphoreAttributes：爲信號量的屬性，一般可以設置爲NULL
 lInitialCount：信號量初始值，必須大於等於0，而且小於等於 lpMaximumCount，如果lInitialCount 的初始值爲0，則該信號量默認爲unsignal狀態，如果lInitialCount的初始值大於0，則該信號量默認爲signal狀態，
 lMaximumCount： 此值爲設置信號量的最大值，必須大於0
lpName：信號量的名字，長度不能超出MAX_PATH ，可設置爲NULL，表示無名的信號量。當lpName不爲空時，可創建有名的信號量，若當前信號量名與已存在的信號量的名字相同時，則該函數表示打開該信號量，這時參數lInitialCount 和 
lMaximumCount 將被忽略。

2.釋放信號量函數

OOL ReleaseSemaphore(  HANDLE hSemaphore,       // handle to semaphore
                          LONG lReleaseCount,      // count increment amount
                          LPLONG lpPreviousCount   // previous count);
參數說明：
hSemaphore：信號量句柄，
lReleaseCount：釋放的數量，一般完成一個等待後調用此函數釋放一個信號量，使得信號量平衡。
lpPreviousCount ：存放以前信號量的數量 ，一般可爲NULL.

二、實例

// 信號量.cpp : 此文件包含 "main" 函數。程序執行將在此處開始並結束。
//

#include <iostream>
#include <Windows.h>
#include <tchar.h>

const TCHAR* szSemaphoreA = _T("_SemaphoreA_");
const TCHAR* szSemaphoreB = _T("_SemaphoreB_");
const TCHAR* szSemaphoreC = _T("_SemaphoreC_");

DWORD WINAPI Thread_1(LPVOID param);
DWORD WINAPI Thread_2(LPVOID param);
DWORD WINAPI Thread_3(LPVOID param);

HANDLE hSM_1;
HANDLE hSM_2;
HANDLE hSM_3;

HANDLE hThread_1;
HANDLE hThread_2;
HANDLE hThread_3;

int main()
{

	// 創建三個信號量

	hSM_1 = CreateSemaphore(NULL, 1, 1, szSemaphoreA);//開始爲signal狀態
	hSM_2 = CreateSemaphore(NULL, 0, 1, szSemaphoreB);//開始爲unsignal狀態，等待hSM_1釋放
	hSM_3 = CreateSemaphore(NULL, 0, 1, szSemaphoreC);//開始爲unsignal狀態，等待hSM_2

	//創建三個線程

	hThread_1 = CreateThread(NULL, 0, Thread_1, NULL, 0, NULL);
	hThread_2 = CreateThread(NULL, 0, Thread_2, NULL, 0, NULL);
	hThread_3 = CreateThread(NULL, 0, Thread_3, NULL, 0, NULL);

	//等待三個線程都執行完
	WaitForSingleObject(hThread_1, INFINITE);
	WaitForSingleObject(hThread_2, INFINITE);
	WaitForSingleObject(hThread_3, INFINITE);

	//三個線程都執行完
	printf("\n\n\t main end \n");

	//關閉句柄
	CloseHandle(hThread_1);
	CloseHandle(hThread_2);
	CloseHandle(hThread_3);
	CloseHandle(hSM_1);
	CloseHandle(hSM_2);
	CloseHandle(hSM_3);
	return 0;
}

DWORD WINAPI Thread_1(LPVOID param)
{
	for (int i = 0; i < 10; i++)
	{
		DWORD dwWait = WaitForSingleObject(hSM_1, INFINITE);

		//每一個wait過後信號量的數量自動減1，這樣就達到了控制同步

		printf("A");
		ReleaseSemaphore(hSM_2, 1, NULL);
	}
	return 0;
}

DWORD WINAPI Thread_2(LPVOID param)
{
	for (int i = 0; i < 10; i++)
	{
		WaitForSingleObject(hSM_2, INFINITE);
		printf("B");
		ReleaseSemaphore(hSM_3, 1, NULL);
	}
	return 0;
}

DWORD WINAPI Thread_3(LPVOID param)
{
	for (int i = 0; i < 10; i++)
	{
		WaitForSingleObject(hSM_3, INFINITE);
		printf("C ");
		ReleaseSemaphore(hSM_1, 1, NULL);
	}

	system("pause");
	return 0;
}

參考：

https://www.cnblogs.com/priarieNew/p/9753419.html

https://blog.csdn.net/KLKFL/article/details/80575074?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase

https://blog.csdn.net/qq_30483585/article/details/79564712?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase