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

Mqtt开发笔记：windows下C++ ActiveMQ客户端介绍、编译和使用 项目需求，需要使用到mqtt协议，之前编译QtMqtt库，不支持队列模式queue（点对点），只支持订阅/发布者模式.，所以使用C++ ActiveMQ实现。
windows C++ 互相等待线程同步示例 windows C++ 互相等待线程同步示例 开发中遇到线程同步问题，可抽象为如下模型： 1、主线程的继续执行的前提是子线程的变量已经初始化完毕。 2、子线程待主线程执行完毕后继续执行后续的初始化操作。 重复1,2执行……直到通信结束。