Windows四大线程技术项目实战（临界区、事件、互斥量、信号量）

一、【临界区】

每个进程中访问临界资源的那段代码称为临界区（Critical Section）（临界 资源是一次仅允许一个进程使用的共享资源）。每次只准许一个进程进入临界区， 进入后不允许其他进程进入。不论是硬件临界资源，还是软件临界资源，多个进程 必须互斥地对它进行访问。
多个进程中涉及到同一个临界资源的临界区称为相关临界区。

【进程进入临界区的调度原则】

如果有若干进程要求进入空闲的临界区，一次仅允许一个进程进入。
任何时候，处于临界区内的进程不可多于一个。如已有进程进入自己的临界区， 则其它所有试图进入临界区的进程必须等待。
进入临界区的进程要在有限时间内退出，以便其它进程能及时进入自己的临界区。
如果进程不能进入自己的临界区，则应让出CPU，避免进程出现“忙等”现象。

代码实现如下：

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

using namespace std;

CRITICAL_SECTION  g_cs;		// 临界区全局变量
char g_Str[100];

DWORD WINAPI ThreadFunc1(PVOID pParam)
{
	EnterCriticalSection(&g_cs);	//进入临界区

	for (int i = 0; i < 100; i++)
	{
		g_Str[i] = 'Y';			//为数组赋值
		Sleep(10);
	}

	LeaveCriticalSection(&g_cs);

	return 0;
}


DWORD WINAPI ThreadFunc2(PVOID pParam)
{
	EnterCriticalSection(&g_cs);	//进入临界区

	for (int i = 0; i < 100; i++)
	{
		g_Str[100 - i - 1] = 'I';	//为数组赋值
		Sleep(10);
	}

	LeaveCriticalSection(&g_cs);

	return 0;
}


int main()
{
	//初始化临界区

	InitializeCriticalSection(&g_cs);

	HANDLE hTH1 = CreateThread(NULL, 0, ThreadFunc1, NULL, 0, NULL);
	HANDLE hTH2 = CreateThread(NULL, 0, ThreadFunc2, NULL, 0, NULL);

	HANDLE TH[2] = { hTH1, hTH2 };

	//等待所有内核对象，TRUE等待所有信号量有效再往下执行，FALSE当有其中一个信号量有效时有向下运行
	WaitForMultipleObjects(2, TH, FALSE, INFINITE);

	//删除临界区
	DeleteCriticalSection(&g_cs);
	printf(g_Str);

	getchar();

	return 0;
}

二、【事件】

事件的主要用途是标志事件的发生，并以此协调线程的执行顺序。

用来通知线程有一些事件已发生，从而启动后继续任务的开始。

事件对象也可以通过通知操作方式来保持线程的同步，并且可以实现不同进程中的线程同步操作。

实现代码如下：

//线程间通信--》事件  Event

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

using namespace std;

HANDLE evRead, evFinish;

DWORD WINAPI ReadThread(PVOID pParam)
{
	// 当等待仍在挂起状态的时候，句柄被关闭
	WaitForSingleObject(evRead, INFINITE);

	cout << "Reading Event: " << endl;

	return 0;
}

DWORD WINAPI WriteThread(PVOID pParam)
{
	cout << "Writing Event: " << endl;
	SetEvent(evRead);


	return 0;
}

int main()
{
	evRead = CreateEvent(NULL, FALSE, FALSE, NULL);
	evFinish = CreateEvent(NULL, FALSE, FALSE, NULL);

	CreateThread(NULL, 0, ReadThread, NULL, 0, NULL);
	Sleep(1000);
	CreateThread(NULL, 0, WriteThread, NULL, 0, NULL);

	WaitForSingleObject(evFinish, INFINITE);	//等待信号量

	cout << "The Program is End,OK\n\n";
	return 0;
}

三、【互斥量】

互斥量又称互斥锁。互斥量是一个可以处于两态之一的变量：解锁和加锁。

如果不需要信号量的计数能力，有时可以使用信号量的一个简化版本，称为互斥量
（mutex）。
互斥量仅仅适用于管理共享资源或一小段代码。
由于互斥量在实现时既容易又有效，这使得互斥量在实现用户空间线程包时非常有 用。

为协调共同对一个共享资源的单独访问而设计的。

实现代码如下：

#include<Windows.h>
#include<iostream>
#include<fstream>
#include<atltime.h>		//CTIME  时间类头文件

using namespace std;

fstream fstrobj;

DWORD WINAPI ThreadFunc1(PVOID pParam)
{
	HANDLE *phMutex = (HANDLE*)pParam;

	for (int i = 1; i <= 1000000; i++)
	{
		WaitForSingleObject(*phMutex, INFINITE);
		fstrobj << "ThreadFunc1:" << i << endl;
		ReleaseMutex(*phMutex);
	}

	return 0;
}

DWORD WINAPI ThreadFunc2(PVOID pParam)
{
	HANDLE *phMutex = (HANDLE*)pParam;

	for (int i = 1; i <= 1000000; i++)
	{
		WaitForSingleObject(*phMutex, INFINITE);
		fstrobj << "ThreadFunc2:" << i << endl;
		ReleaseMutex(*phMutex);
	}

	return 0;
}


int main()
{
	//获取初始当前时间
	CTime timebg = CTime::GetCurrentTime();
	int nHour = timebg.GetHour();
	int nMin = timebg.GetMinute();
	int nSec = timebg.GetSecond();


	fstrobj.open("MutexDataFile.txt", ios::out);

	if (!fstrobj.is_open())
	{
		cout << "文件打开失败！" << endl;
	}


	HANDLE hMutex = CreateMutex(NULL, FALSE, L"PrintMutexDataInfo IS:");

	HANDLE TH1 = CreateThread(NULL, 0, ThreadFunc1, &hMutex, 0, NULL);
	HANDLE TH2 = CreateThread(NULL, 0, ThreadFunc2, &hMutex, 0, NULL);

	HANDLE hTH[2] = { TH1, TH2 };
	WaitForMultipleObjects(2, hTH, TRUE, INFINITE);  // 等待互斥量对象

	CloseHandle(hMutex);
	fstrobj.close();


	//获取结束当前时间
	CTime timeed = CTime::GetCurrentTime();
	int nHour2 = timeed.GetHour();
	int nMin2 = timeed.GetMinute();
	int nSec2 = timeed.GetSecond();

	//时间差变量
	CTimeSpan timeSpan;
	timeSpan = timeed - timebg;

	// 统计出执行200万次需要多长时间
	cout << "共用时：" << timeSpan.GetHours() << "小时" << timeSpan.GetMinutes()
		<< "分钟" << timeSpan.GetSeconds() << "秒" << endl;


	return 0;
}

四、【信号量（Semaphores）】

（主要是实现同步，可以跨进程） 信号量是一个内核对象，可用来管理大量有限的系统资源
一个使用计数
32位整数，最大资源数量
32位整数，当前资源数量

信号量使用规则：
当前资源数量大于0，则等待信号量的线程获得资源继续运行，当前资源数量 减1
当前资源数量等于0，则等待信号量的线程继续等待，直到有线程释放信号量， 使当前资源数量大于0

创建信号量

HANDLE CreateSemaphore(  PSECURITY_ATTRIBUTES psa, 
	LONG lInitialCount, // initial count 

	LONG lMaximumCount,  PCTSTR pszName                    
);

为现有的一个已命名信号机对象创建一个新句柄。

HANDLE OpenSemaphore(
DWORD fdwAccess, 
BOOL bInheritHandle, // inheritance option  
PCTSTR pszName // object name ); 

SEMAPHORE_ALL_ACCESS 要求对信号量的完全访问；
SEMAPHORE_MODIFY_STATE 允许使用ReleaseSemaphore函数；
SYNCHRONIZE 允许使用信号量同步。

释放信号量

ReleaseSemaphore(
   	HANDLE hSem,
   	LONG lReleaseCount,
   	PLONG plPreviousCount
   );

等待互斥量

DWORD WaitForSingleObject( 
HANDLE hHandle, 
DWORD dwMilliseconds 
);

实现代码如下：

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

DWORD WINAPI ThreadFunc1(LPVOID lParam);
DWORD WINAPI ThreadFunc2(LPVOID lParam);
DWORD WINAPI ThreadFunc3(LPVOID lParam);
DWORD WINAPI ThreadFunc4(LPVOID lParam);
DWORD WINAPI ThreadFunc5(LPVOID lParam);
DWORD WINAPI ThreadFunc6(LPVOID lParam);
DWORD WINAPI ThreadFunc7(LPVOID lParam);

HANDLE hSM1;
HANDLE hSM2;
HANDLE hSM3;
HANDLE hSM4;
HANDLE hSM5;
HANDLE hSM6;
HANDLE hSM7;

HANDLE hTH1;
HANDLE hTH2;
HANDLE hTH3;
HANDLE hTH4;
HANDLE hTH5;
HANDLE hTH6;
HANDLE hTH7;

int main()
{
	// 创建6个信号量
	hSM1 = CreateSemaphore(NULL, 1, 1, "V");
	hSM2 = CreateSemaphore(NULL, 0, 1, "i");
	hSM3 = CreateSemaphore(NULL, 0, 1, "c");
	hSM4 = CreateSemaphore(NULL, 0, 1, "o");
	hSM5 = CreateSemaphore(NULL, 0, 1, "N");
	hSM6 = CreateSemaphore(NULL, 0, 1, "B");
	hSM7 = CreateSemaphore(NULL, 0, 1, " ");

	// 创建6个线程
	hTH1 = CreateThread(NULL, 0, ThreadFunc1, NULL, 0, NULL);
	hTH2 = CreateThread(NULL, 0, ThreadFunc2, NULL, 0, NULL);
	hTH3 = CreateThread(NULL, 0, ThreadFunc3, NULL, 0, NULL);
	hTH4 = CreateThread(NULL, 0, ThreadFunc4, NULL, 0, NULL);
	hTH5 = CreateThread(NULL, 0, ThreadFunc5, NULL, 0, NULL);
	hTH6 = CreateThread(NULL, 0, ThreadFunc6, NULL, 0, NULL);
	hTH7 = CreateThread(NULL, 0, ThreadFunc7, NULL, 0, NULL);

	// 等待6个线程都执行完毕后
	WaitForSingleObject(hTH1, INFINITE);
	WaitForSingleObject(hTH2, INFINITE);
	WaitForSingleObject(hTH3, INFINITE);
	WaitForSingleObject(hTH4, INFINITE);
	WaitForSingleObject(hTH5, INFINITE);
	WaitForSingleObject(hTH6, INFINITE);
	WaitForSingleObject(hTH7, INFINITE);


	// 关闭句柄 
	CloseHandle(hTH1);
	CloseHandle(hTH2);
	CloseHandle(hTH3);
	CloseHandle(hTH4);
	CloseHandle(hTH5);
	CloseHandle(hTH6);
	CloseHandle(hTH7);

	// 关闭信号量
	CloseHandle(hSM1);
	CloseHandle(hSM2);
	CloseHandle(hSM3);
	CloseHandle(hSM4);
	CloseHandle(hSM5);
	CloseHandle(hSM6);
	CloseHandle(hSM7);

	printf("\n\n\n");

	return 0;
}

DWORD WINAPI ThreadFunc1(LPVOID lParam)
{
	for (int i = 0; i < 10; i++)
	{
		DWORD dwWait = WaitForSingleObject(hSM1, INFINITE);
		printf("V");
		ReleaseSemaphore(hSM2, 1, NULL);
	}
	return 0;
}

DWORD WINAPI ThreadFunc2(LPVOID lParam)
{
	for (int i = 0; i < 10; i++)
	{
		DWORD dwWait = WaitForSingleObject(hSM2, INFINITE);
		printf("i");
		ReleaseSemaphore(hSM3, 1, NULL);
	}
	return 0;
}

DWORD WINAPI ThreadFunc3(LPVOID lParam)
{
	for (int i = 0; i < 10; i++)
	{
		DWORD dwWait = WaitForSingleObject(hSM3, INFINITE);
		printf("c");
		ReleaseSemaphore(hSM4, 1, NULL);
	}
	return 0;
}

DWORD WINAPI ThreadFunc4(LPVOID lParam)
{
	for (int i = 0; i < 10; i++)
	{
		DWORD dwWait = WaitForSingleObject(hSM4, INFINITE);
		printf("o");
		ReleaseSemaphore(hSM5, 1, NULL);
	}
	return 0;
}

DWORD WINAPI ThreadFunc5(LPVOID lParam)
{
	for (int i = 0; i < 10; i++)
	{
		DWORD dwWait = WaitForSingleObject(hSM5, INFINITE);
		printf("N");
		ReleaseSemaphore(hSM6, 1, NULL);
	}
	return 0;
}

DWORD WINAPI ThreadFunc6(LPVOID lParam)
{
	for (int i = 0; i < 10; i++)
	{
		DWORD dwWait = WaitForSingleObject(hSM6, INFINITE);
		printf("B");
		ReleaseSemaphore(hSM7, 1, NULL);
	}
	return 0;
}

DWORD WINAPI ThreadFunc7(LPVOID lParam)
{
	for (int i = 0; i < 10; i++)
	{
		DWORD dwWait = WaitForSingleObject(hSM7, INFINITE);
		printf(" ");
		ReleaseSemaphore(hSM1, 1, NULL);
	}
	return 0;
}

小结

临界区：主要通过对多线程串行化来访问公共资源或一段代码，速度快，适合控制数据访问场合；

互斥量：为协议共同对一个共享资源数据的单独访问而设计的；

信号量：为控制一个具有有限数量用户资源而设计；

事件：用来通知线程有一些事件即将发生，从而启动后继任何的开始。