Windows核心编程：第8章 用户模式下的线程同步

Github

https://github.com/gongluck/Windows-Core-Program.git

//第8章 用户模式下的线程同步.cpp: 定义应用程序的入口点。
//

#include "stdafx.h"
#include "第8章 用户模式下的线程同步.h"

LONG g_i = 100;
LONG g_b = FALSE;

CRITICAL_SECTION g_cs; //关键段
SRWLOCK g_rw; //读写锁
CONDITION_VARIABLE g_cv; //条件变量


DWORD WINAPI Thread1(PVOID param)
{
	for (int i = 0; i < 100; ++i)
	{
		EnterCriticalSection(&g_cs);
		g_i += i;
		LeaveCriticalSection(&g_cs);
	}
	return 0;
}

DWORD WINAPI Thread2(PVOID param)
{
	for (int i = 0; i < 100; ++i)
	{
		if (TryEnterCriticalSection(&g_cs))
		{
			g_i += i;
			LeaveCriticalSection(&g_cs);
		}
		else
			SwitchToThread();
	}
	return 0;
}

DWORD WINAPI Thread3(PVOID param)
{
	for (int i = 0; i < 100; ++i)
	{
		AcquireSRWLockExclusive(&g_rw);
		//写
		OutputDebugString(TEXT("------------AcquireSRWLockExclusive succeed.\n"));
		ReleaseSRWLockExclusive(&g_rw);
	}
	return 0;
}

DWORD WINAPI Thread4(PVOID param)
{
	for (int i = 0; i < 100; ++i)
	{
		AcquireSRWLockShared(&g_rw);
		//读
		OutputDebugString(TEXT("------------AcquireSRWLockShared succeed.\n"));
		ReleaseSRWLockShared(&g_rw);
	}
	return 0;
}

DWORD WINAPI Thread5(PVOID param)
{
	int n = 0;
	for (int i = 0; i < 100; ++i)
	{
		EnterCriticalSection(&g_cs);
		++n;
		if (n >= 100)
			break;
		if(g_i <= 0)
			SleepConditionVariableCS(&g_cv, &g_cs, INFINITE); //解锁等待条件变量，返回时再加锁
		g_i--;
		LeaveCriticalSection(&g_cs);
	}
	return 0;
}

DWORD WINAPI Thread6(PVOID param)
{
	for (int i = 0; i < 100; ++i)
	{
		if (TryEnterCriticalSection(&g_cs))
		{
			g_i++;
			WakeConditionVariable(&g_cv); //唤醒等待条件变量的线程
			LeaveCriticalSection(&g_cs);
		}
		else
			SwitchToThread();
	}
	return 0;
}

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
	_In_opt_ HINSTANCE hPrevInstance,
	_In_ LPWSTR    lpCmdLine,
	_In_ int       nCmdShow)
{
	//原子操作Interlocked系列
	LONG newl = InterlockedAdd(&g_i, 1);
	LONG oldl = InterlockedExchange(&g_i, 10);
	oldl = InterlockedCompareExchange(&g_i, 100, 10);
	LONGLONG oldll = InterlockedAnd(&g_i, 0x0001);

	//旋转锁！
	while (InterlockedExchange(&g_b, TRUE) == TRUE)
		Sleep(0);

	//使用关键段
	//InitializeCriticalSection(&g_cs);
	BOOL bret = InitializeCriticalSectionAndSpinCount(&g_cs, 1);//初始化关键段并用上旋转锁
	oldl = SetCriticalSectionSpinCount(&g_cs, 4000);
	g_i = 0;
	HANDLE hthread1 = CreateThread(nullptr, 0, Thread1, nullptr, 0, nullptr);
	HANDLE hthread2 = CreateThread(nullptr, 0, Thread2, nullptr, 0, nullptr);

	WaitForSingleObject(hthread1, INFINITE);
	WaitForSingleObject(hthread2, INFINITE);
	CloseHandle(hthread1);
	hthread1 = nullptr;
	CloseHandle(hthread2);
	hthread2 = nullptr;

	//使用读写锁
	InitializeSRWLock(&g_rw);
	HANDLE hthread3 = CreateThread(nullptr, 0, Thread3, nullptr, 0, nullptr);
	HANDLE hthread4 = CreateThread(nullptr, 0, Thread4, nullptr, 0, nullptr);

	WaitForSingleObject(hthread3, INFINITE);
	WaitForSingleObject(hthread4, INFINITE);
	CloseHandle(hthread3);
	hthread3 = nullptr;
	CloseHandle(hthread4);
	hthread4 = nullptr;

	//条件变量(误入锁？)
	InitializeConditionVariable(&g_cv);
	g_i = 0;
	HANDLE hthread5 = CreateThread(nullptr, 0, Thread5, nullptr, 0, nullptr);
	HANDLE hthread6 = CreateThread(nullptr, 0, Thread6, nullptr, 0, nullptr);

	WaitForSingleObject(hthread5, INFINITE);
	WaitForSingleObject(hthread6, INFINITE);
	CloseHandle(hthread5);
	hthread5 = nullptr;
	CloseHandle(hthread6);
	hthread6 = nullptr;

	DeleteCriticalSection(&g_cs);

	system("pause");
	return 0;
}