C++windows内核编程笔记day14 其他线程同步技术-阿里云开发者社区

线程同步技术：
原子锁
临界区（段）
互斥
事件
信号量(线程示例时已经使用过)
可等候定时器

使用范围：原子锁<临界区<互斥
效率：原子锁>临界区（用户态）>互斥（内核态）
一般用临界区。

//等候多个信号
DWORD WaitForMultipleObjects(
DWORD nCount, // number of handles in array
CONST HANDLE *lpHandles, // object-handle array
BOOL bWaitAll, // wait option
DWORD dwMilliseconds // time-out interval
);
bWaitAll:
TRUE-所有句柄都有信号才结束等候
FALSE-有一个就结束等候(返回值为有信号的句柄的下标)
dwMilliseconds:
INFINITE-等待
等待的毫秒数-时间到了或信号到了就结束
使用：
HANDLE ht[2]={0};
ht[0]=hthread1;
ht[1]=hthread2;
WaitForMultipleObjects(2,ht,TRUE,INFINITE);
在临界资源前加 _declspec(thread) 可以解决部分操作被覆盖的问题。
day76 pm over
原子锁函数的使用:
InterlockedIncrement --自加
InterlockedDecrement --自减
LONG InterlockedCompareExchange(
LPLONG volatile Destination, // destination address
LONG Exchange, // exchange value
LONG Comperand // value to compare
);
InterlockedExchange --等号赋值
原子锁实现:
锁住变量所在内存,同一时间只能有一个线程操作.
示例:
long g_val=0;
InterlockedIncrement(&g_val);

原子锁使用示例:

#include "stdafx.h"
#include<windows.h>
#include <STDIO.H>
long g_val=0;
DWORD CALLBACK TestProc1(LPVOID param)
{
//	sprintf(g_txt,"%s",(char*)param);
	//char*txt=(char*)param;
	for(int i=0;i<10000;i++)
	{
		//g_val++;
		InterlockedIncrement(&g_val);
		//printf("test1 thread,g_val=%d!\n",g_val);
	}

	return 0;
}
DWORD CALLBACK TestProc2(LPVOID param)
{
	//sprintf(g_txt,"%s",(char*)param);
	//char*txt=(char*)param;
	for(int i=0;i<10000;i++)
	{
		//g_val++;
		InterlockedIncrement(&g_val);
		InterlockedExchange
		//printf("test2 thread,g_val=%d!\n",g_val);
	}
	return 0;
}
int main(int argc, char* argv[])
{
	HANDLE ht[2]={0};
	DWORD tid=0;
	ht[0]=CreateThread(NULL,0,TestProc1,NULL,0,&tid);
	ht[1]=CreateThread(NULL,0,TestProc2,NULL,0,&tid);
	WaitForMultipleObjects(2,ht,TRUE,INFINITE);
	printf("最终结果：%d\n",g_val);
	CloseHandle(ht[0]);
	CloseHandle(ht[1]);
	return 0;
}

临界区:
锁定一段代码,防止多个线程同时使用该段代码.
１、初始化临界区(主线程调用):
VOID InitializeCriticalSection(
LPCRITICAL_SECTION lpCriticalSection // critical section
);
２、进入临界区(子线程调用)
VOID EnterCriticalSection(
LPCRITICAL_SECTION lpCriticalSection // critical section
);
３、离开临界区(子线程调用)
VOID LeaveCriticalSection(
LPCRITICAL_SECTION lpCriticalSection // critical section
);
４、删除临界区(主线程调用)
VOID DeleteCriticalSection(
LPCRITICAL_SECTION lpCriticalSection // critical section
);
临界区使用示例:
CRITICAL_SECTION cs={0};
void Thread()
{
DWORD tid=0;
char *txt="**************************";
HANDLE hthread1=CreateThread(NULL,0,TestProc1,txt,
0,&tid);
char *txt2="—————————————";
HANDLE hthread2=CreateThread(NULL,0,TestProc2,txt2,
0,&tid);
//SuspendThread(hthread1);
//ResumeThread(hthread2);
HANDLE ht[2]={0};
ht[0]=hthread1;
ht[1]=hthread2;
WaitForMultipleObjects(2,ht,TRUE,INFINITE);
CloseHandle(hthread1);
CloseHandle(hthread2);
}

int main(int argc, char* argv[])
{
InitializeCriticalSection(&cs);
Thread();
DeleteCriticalSection(&cs);
return 0;
}
//在线程1处理函数TestProc1中锁定代码
EnterCriticalSection(&cs);
printf("*****************************\n");
LeaveCriticalSection(&cs);
//在线程2处理函数TestProc2中锁定代码
EnterCriticalSection(&cs);
printf("____________________\n");
LeaveCriticalSection(&cs);

互斥Mutex（可以通过互命名的方式跨进程使用）：
1、创建互斥，返回句柄
HANDLE CreateMutex( LPSECURITY_ATTRIBUTES lpMutexAttributes, // SD
BOOL bInitialOwner,// initial owner，是否本线程拥有
LPCTSTR lpName // object name
);
bInitialOwner:
TRUE-调用CreateMutex的线程拥有互斥
FALSE-创建的时候没有线程拥有互斥
2、等候互斥
WaitFor
3、释放互斥
BOOL ReleaseMutex(HANDLE hMutex);
4、关闭互斥句柄
CloseHandle(HANDLE hMutex);

互斥示例：
HANDLE g_hMutex=0;
//在线程1处理函数中使用互斥体等待
WaitForSingleObject(g_hMutex,INFINITE);
printf("*****************************\n");
ReleaseMutex(g_hMutex);
//在线程2处理函数中使用互斥体等待
WaitForSingleObject(g_hMutex,INFINITE);
printf("………………………………………………………………………………\n");
ReleaseMutex(g_hMutex);
void Thread()
{
DWORD tid=0;
char *txt="**************************";
HANDLE hthread1=CreateThread(NULL,0,TestProc1,txt,
0,&tid);
char *txt2="—————————————";
HANDLE hthread2=CreateThread(NULL,0,TestProc2,txt2,
0,&tid);
HANDLE ht[2]={0};
ht[0]=hthread1;
ht[1]=hthread2;
WaitForMultipleObjects(2,ht,TRUE,INFINITE);
CloseHandle(hthread1);
CloseHandle(hthread2);
}

int main(int argc, char* argv[])
{
g_hMutex=CreateMutex(0,FALSE,"m1");
Thread();
CloseHandle(g_hMutex);
return 0;
}
事件：
1、创建事件
HANDLE CreateEvent( LPSECURITY_ATTRIBUTES lpEventAttributes, // SD
BOOL bManualReset,// reset type
BOOL bInitialState,// initial state
LPCTSTR lpName // object name
);
bManualReset：
true-调用WaitFor(……)后，手动调用ResetEvent(复位)
false-调用WaitFor(……)时，WaitFor(……)中会自动复位
2、等候信号
WaitForSingleObject/WaitForMultipleObjects
3、将事件设置成有信号状态
BOOL SetEvent( HANDLE hEvent);
将事件设置成无信号状态
BOOL ResetEvent( HANDLE hEvent);
4关闭事件

事件使用示例主要代码：

HANDLE g_hevent=0;
DWORD CALLBACK PrintProc(LPVOID param)
{
while(1)
{
WaitForSingleObject(g_hevent,INFINITE);//有信号才执行
ResetEvent(g_hevent);//把信号设置为无信号，等待其他线程发信号
printf("**************************\n");

}
return 0;
}
DWORD CALLBACK CtrlProc(LPVOID param)
{
int i=0;
while(1)
{
SetEvent(g_hevent);//发一个信号
Sleep(1000);
i++;
if(i==1000) break;
}
return 0;
}
void Thread()
{
DWORD tid=0;
char *txt="**************************";
HANDLE hthread1=CreateThread(NULL,0,PrintProc,txt,
0,&tid);
char *txt2="—————————————";
HANDLE hthread2=CreateThread(NULL,0,CtrlProc,txt2,
0,&tid);
HANDLE ht[2]={0};
ht[0]=hthread1;
ht[1]=hthread2;
WaitForMultipleObjects(2,ht,TRUE,INFINITE);
CloseHandle(hthread1);
CloseHandle(hthread2);
}

int main(int argc, char* argv[])
{
g_hevent=CreateEvent(0,TRUE,FALSE,"e1");
Thread();
CloseHandle(g_hevent);
return 0;

}

可等候定时器
解决程序之间的通知问题,第一次启动时间以100纳秒(0.0001毫秒)为单位.
1、创建可等候定时器
HANDLE CreateWaitableTimer(
LPSECURITY_ATTRIBUTES lpTimerAttributes, // SD
BOOL bManualReset,// 是否手动复位
LPCTSTR lpTimerName // 名称,可以为NULL
);
2、设置定时器
BOOL SetWaitableTimer(
HANDLE hTimer, // handle to timer
const LARGE_INTEGER *pDueTime, //第一次启动时间
LONG lPeriod,//间隔时间
PTIMERAPCROUTINE pfnCompletionRoutine,// 回调函数
LPVOID lpArgToCompletionRoutine,//回调函数参数
BOOL fResume//待机处理标识
);
pDueTime:
正数-绝对时间(年月日时分秒)
负数-绝对值为相对时间(0.0001毫秒为单位)
lPeriod:
以毫秒为单位,为0时,只执行一次.
fResume:
TRUE-如果机器正要待机，能解除待机
FALSE-放弃待机
3、等候信号
WaitFor(...)
注意:可等候定时器只适用于NT5.0及以上版本,得定义系统版本
#define _WIN32_WINNT 0X500

示例:

// winTimer.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#define _WIN32_WINNT 0X500
#include <WINDOWS.H>
#include<STDIO.H>
HANDLE g_hTimer=0;
DWORD WINAPI TestProc(  LPVOID lpParameter)
{
	while(1)
	{
		WaitForSingleObject(g_hTimer,INFINITE);
		printf("************************\n");
	}
}
int main(int argc, char* argv[])
{
	g_hTimer=CreateWaitableTimer(NULL,FALSE,"t1");
	//INT64 nDueTime=-10000000;//相对时间
	//LARGE_INTEGER li=(LARGE_INTEGER*)&nDueTime;
	SYSTEMTIME st={0};
	st.wYear=2014;
	st.wMonth=7;
	st.wDay=13;
	st.wHour=15;
	st.wMinute=13;
	st.wSecond=30;
	FILETIME ft={0};
	SystemTimeToFileTime(&st,&ft);//系统时间转换为本地时间
	FILETIME ft2={0};
	LocalFileTimeToFileTime(&ft,&ft2);//将本地时间转换为全球标准时间
	LARGE_INTEGER li={0};
	li.HighPart=ft2.dwHighDateTime;
	li.LowPart=ft2.dwLowDateTime;

	DWORD tid=0;
	SetWaitableTimer(g_hTimer,&li,3000,NULL,NULL,FALSE);
	HANDLE ht=CreateThread(NULL,0,TestProc,NULL,0,&tid);
	WaitForSingleObject(ht,INFINITE);
	CloseHandle(ht);
	CloseHandle(g_hTimer);
	return 0;
}

win32 编程部分结束。

C++windows内核编程笔记day14 其他线程同步技术

热门文章

最新文章

相关课程

相关电子书

相关实验场景