C++windows内核编程笔记day14 其他线程同步技术-真爱无限的知识驿站

29

2014
07

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 编程部分结束。

Tags:

发布:pukuimin | 分类:linux/proc/c/c++ | 评论:0 | 浏览:
时间:2014-7-29 9:15:54

评论列表:

发表评论:

◎欢迎参与讨论，请在这里发表您的看法、交流您的观点。

真爱无限的知识驿站

技术、生活经验、工作经验等方面的交流与分享

29

2014
07