原子锁
临界区（段）
互斥
事件
信号量(线程示例时已经使用过)
可等候定时器
使用范围：原子锁<临界区<互斥
效率： 原子锁>临界区（用户态）>互斥（内核态）
一般用临界区。
//等候多个信号
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关闭事件
事件使用示例主要代码：
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 编程部分结束。