Windows核心编程笔记（九）使用内核对象进行线程同步

上一章作者介绍了用户模式下的线程同步，虽然它们有很好的性能，但是他们功能有限并不是能够胜任实际工作中出现的复杂情况，以及特殊的要求，于是Windwos提供了一些用于线程同步的内核对象，它们根据不同的应用场景而设计，满足不同的环境下的线程同步的要求，因为是基于内核对象来完成同步，因此线程同步时可以跨进程的。

这些内核对象包括，事件，可等待计时器，信号量，互斥量。

在具体介绍每个线程同步内核对象之前，需要了解两个基础的用于等待内核对象的函数WaitForSingleObjectEx 和  WaitForMultipleObjects.

DWORD WINAPI WaitForSingleObject(
__in  HANDLE hHandle,  //内核对象句柄
__in  DWORD dwMilliseconds  //等待的时间、单位：毫秒  如果指定（INFINITE）表示无信号一直等待。
);

返回值  

WAIT_ABANDONED   （只在对象为互斥量类型时用到， 表示上一个线程因为错误，线程异常终止，内核对象才变为了有信号的）

WAIT_OBJECT_0  （内核对象有信号）

 

WAIT_TIMEOUT    （等待时间到了）

 

WAIT_FAILED  （参数错误，函数调用失败）

 

DWORD WINAPI WaitForMultipleObjects(
__in  DWORD nCount,  （多少个要等待的对象）
__in  const HANDLE *lpHandles,  内核对象句柄数组
__in  BOOL bWaitAll,  （是否等待所有对象有信号才返回）
__in  DWORD dwMilliseconds  (等待时间）
);

该API函数等待一个或者一组线程同步内核对象，由 bWaitAll指定等待方式， bWaitAll == 1在所有对象处于有信号状态返回， bWaitAll=0 只有其中一个处于有信号状态就返回

返回值

WAIT_OBJECT_0 to (WAIT_OBJECT_0 + nCount– 1)      (WAIT_OBJECT_0+N)表示第N个对象处于有信号状态在bWaitAll为1时，如果bWaitAll为0    WAIT_OBJECT_0表示所有对象处于有信号状态，成功返回。

 

WAIT_ABANDONED_0 to (WAIT_ABANDONED_0 + nCount– 1)  （如果bWaitAll为1，WAIT_ABANDONED_0表示句柄数组中至少有一个是互斥量对象的句柄，如果bWaitAll为0，那么WAIT_ABANDONED_0+N表示句柄数组中第N个是一个互斥量句柄，上一个线程没有释如果放互斥量的情况下异常终止）

 

WAIT_TIMEOUT   （同WaitForSingleObject）

 

WAIT_FAILED    （WaitForSingleObject）

（一）事件内核对象

事件内核对象在上一章的用户模式的同步对象 CriticalSection 中已经提到，CriticalSection只是用了它的自动重置模式，自动重置模式在WaitForSingleObject获取到有信号后自动将对象设置为无信号状态并返回。

临界区对象在EnterCriticalSection中调用执WaitForSingleObjec行等待，在LeaveCriticalSection中调用SetEvent将事件对象重置为有信号状态。

此外事件内核对象可以使用手动重置模式，在手动模式下，WaitForSingleObject并改变其状态，需要手动调用SetEvent将对象置为有信号状态，或者调用ResetEvent将对象置为无信号状态，在将对象置为有信号状态时，所有使用WaitXX执行等待的线程都可以返回WAIT_OBJECT_0 得到调度。

API：

HANDLE WINAPI CreateEvent(
__in_opt  LPSECURITY_ATTRIBUTES lpEventAttributes,
__in      BOOL bManualReset, //TRUE自动模式 FALSE手动模式
__in      BOOL bInitialState,//初始值是否是有信号的，TRUE （是），FALSE(不是)
__in_opt  LPCTSTR lpName
);

BOOL WINAPI SetEvent(
__in  HANDLE hEvent
);

BOOL WINAPI ResetEvent(
__in  HANDLE hEvent
);

适应：在自动模式下与 临界区对象  互斥量 SRWLock的互斥模式  功能是一样的，都保证对共享资源的访问在同一时间只运行一个线程独占。

区别  ：临界区对象在使用内核机制前有个一个旋转锁等待循环，如果在确定对共享资源独占期间占用很少的CPU周期，应该使用临界区对象。

              如果区分写共享资源和读共享资源的线程，即存在生产和消费两种类型的线程，使用SRWLock

如果要进行进程间的同步，或者在独占共享资源之后的操作可能占用很多的CPU周期，如等待用户输入并把用户的输入写入共享资源，应该使用事件或者互斥量，这两个内核同步对象，使线程在无信号状态不参与调度，不占用CPU，而不是SRWLock那样循环的使用原子访问和NOP

                 互斥量和事件对象的区别很小，互斥量允许一个在异常终止后系统自己是否它对对象的占用，从而避免死锁。事件对象则多了一个手动模式，允许多个线程同时得到执行

（二）可等待的计时器
可等待计时器，类似于SetTimer,它设置一个定时器，并可以设置周期循环触发的时间，在时间到期时所有等待线程可以得到执行（手动模式），或者一个等待线程被唤醒（自动模式）。同时它还可以设置一个APC回调函数，在时间到期时将ACP挂入 SetWaitableTimer 主调线程的APC队列中。

API:

HANDLE WINAPI CreateWaitableTimer(
__in_opt  LPSECURITY_ATTRIBUTES lpTimerAttributes,
__in      BOOL bManualReset, //自动还是手动模式
__in_opt  LPCTSTR lpTimerName   //内核对象名字
);

BOOL WINAPI SetWaitableTimer(
__in      HANDLE hTimer,
__in      const LARGE_INTEGER *pDueTime,   //触发的时间，如果为负数表示相对时间，单位纳秒
__in      LONG lPeriod,                    //触发后多久循环触发一次一次
__in_opt  PTIMERAPCROUTINE pfnCompletionRoutine,  //APC回调函数地址
__in_opt  LPVOID lpArgToCompletionRoutine,        //回调函数参数
__in      BOOL fResume                        //是否唤醒睡眠中的系统，利用电源管理
);

取消对象的活动状态，不再触发。

BOOL WINAPI CancelWaitableTimer(
__in  HANDLE hTimer
);

测试代码 使用自动重置模式，10秒后触发，之后每秒触发一次

#include <iostream>
#include <stdio.h>
#include <windows.h>
#include <thread>
#include <winbase.h>

//using namespace std;
using std::cout;
using std::endl;

HANDLE hTimer = NULL;
volatile LONG g_IsPassed = 0;

void ThreadForTimer(int pParameter)
{
//int ID  = *static_cast<int*>(pParameter);
int ID = pParameter;
InterlockedAdd(&g_IsPassed,1);
while(1)
{
cout.flush();
if(WaitForSingleObject(hTimer,INFINITE) == WAIT_OBJECT_0)
{
cout<<"Thread "<<ID<<" has obtained the single Time:"<<GetTickCount()<<endl;
}
else
{
cout<<"Thread exception occurred"<<endl;
}
}

}

int main(int argc, char *argv[])
{
LARGE_INTEGER liDueTime;

liDueTime.QuadPart = -100000000L;

// Create an unnamed waitable timer.
hTimer = CreateWaitableTimer(NULL, FALSE, NULL);
if (NULL == hTimer)
{
printf("CreateWaitableTimer failed (%d)\n", GetLastError());
return 1;
}

printf("Waiting for 10 seconds   Time:%d \n ",GetTickCount());

if (!SetWaitableTimer(hTimer, &liDueTime, 1000, NULL, NULL, 0))
{
printf("SetWaitableTimer failed (%d)\n", GetLastError());
return 2;
}

for(int i = 0; i != 5; ++i)
{
new std::thread(ThreadForTimer,i);
while(1)
{
if(InterlockedCompareExchange(&g_IsPassed,0,1) == 1)  break;
YieldProcessor();
}
}
SleepEx(INFINITE,TRUE);

return 0;

}

运行结果



  hTimer = CreateWaitableTimer(NULL, FALSE, NULL);   第二个参数改为TRUE   手动模式后



每个线程一直都处于可调度状态

可以等待计数器内核对象的适用情况非常的明确，当需要一个定时器在某和时间点唤醒等待线程，或者按一定时间循环唤醒时。

（三）信号量内核对象

信号量内核对象用来对资源进行计数，在需要对资源使用做限制的时候信号量非常有用，在内部它存放了一个当前可用资源数的变量，和一个最大资源数的变量，每个等待线程使用等待函数时,'如果可以资源数大于0，将其值减一并返回，如果可以资源数已经为0则等待函数进入睡眠，可以通过ReleaseSemaphore增加可以用资源数量，对计数访问修改都是使用的原子操作，保证了计数在多线程下不被破坏。

API:

HANDLE WINAPI CreateSemaphore(
__in_opt  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
__in      LONG lInitialCount,  可用数量
__in      LONG lMaximumCount,  最大数量
__in_opt  LPCTSTR lpName
);

BOOL WINAPI ReleaseSemaphore(
__in       HANDLE hSemaphore,
__in       LONG lReleaseCount,  增加多少

__out_opt  LPLONG lpPreviousCount
);

测试代码：

#include <iostream>
#include <stdio.h>
#include <windows.h>
#include <thread>
#include <winbase.h>
#include <string>
#include <random>
#include <vector>

//using namespace std;
using std::cout;
using std::endl;

HANDLE g_hSemaphore;
HANDLE g_hEvent;
std::vector<int> vtrBuffer;

void ThreadForSemaphoreInc()
{
std::random_device rd;
while(1)
{
if(WaitForSingleObject(g_hEvent,INFINITE) == WAIT_OBJECT_0)
{
for(int i = 0; i !=10; ++i)
{
vtrBuffer.push_back(rd()%100);
}
ReleaseSemaphore(g_hSemaphore,10,NULL);
SetEvent(g_hEvent);

}
cout<<"The buffer has been full"<<endl<<endl;
Sleep(5*1000);

}

}
void ThreadForSemaphoreDec()
{
HANDLE handles[2] = {g_hEvent,g_hSemaphore};
while(1)
{
if(WaitForMultipleObjects(2,handles,TRUE,INFINITE) == WAIT_OBJECT_0)
{
cout<<"Decreasing the buffer,the popuped value is "<<vtrBuffer.back()<<endl;
vtrBuffer.pop_back();
SetEvent(g_hEvent);
}

}
}

int main(int argc, char *argv[])
{
g_hEvent = CreateEvent(NULL,FALSE,TRUE,NULL);
if(!g_hEvent) cout<<"CreateEvent failed and the error code is "<<GetLastError()<<endl;

g_hSemaphore = CreateSemaphore(NULL,0,10,NULL);
if(!g_hEvent) cout<<"CreateSemaphore failed and the error code is "<<GetLastError()<<endl;

new std::thread(ThreadForSemaphoreInc);

new std::thread(ThreadForSemaphoreDec);
Sleep(1000*1000);

return 0;
}

运行结果



（四）互斥量对象

互斥量内核对象用来确保一个线程独占对一个资源的访问。互斥量对象包含一个使用计数，线程ID，和一个递归计数。互斥量与关键段的行为完全相同，但互斥量是内核对象，而关键段是用户模式下的同步对象。

互斥量规则：

（1）如果线程ID为0（无效线程ID），那么该互斥量不为任何线程占用，它处于触发在状态

（2）如果线程ID为非零值，那么有一个线程已经占用了该互斥量，它处于未触发在状态

（3）与其他内核对象不同，操作系统对互斥量进行了特殊处理，允许它们违反一些常规的规则。

 为了获得对被保护资源的访问权，线程要调用等待函数并传入互斥量句柄。在内部，等待函数会检查线程ID是否为0，如果为0，等待线程将互斥量对象线程ID设为当前线程

ID，递归计数为1。否则，主调线程将会被挂起。当其他线程完成对保护资源的互斥访问，释放对互斥量的占有时，互斥量的线程ID被设为0，原来被挂起的线程变为可调度状态，并将互斥量对象对象ID设为此线程ID，递归计数为1。

 

前面一直提到递归计数，却没有解释它的意思。当线程试图等待一个未触发的互斥量对象，此时通常处于等待状态。但是系统会检查想要获得互斥量的线程的线程ID与互斥量对象内部记录的线程ID是否相同。如果相同，那么系统会让线程保持可调度状态，即使该互斥量尚未触发。每次线程等待成功一个互斥量，互斥对象的递归计数就会被设为1。因此，使递归对象大于1 的唯一途径是让线程多次等待同一个互斥量。

当目前占有互斥量的线程不再需要访问互斥资源时，它必须调用ReleaseMutex来释放互斥量。

API:

HANDLE WINAPI CreateMutex(
__in_opt  LPSECURITY_ATTRIBUTES lpMutexAttributes,
__in      BOOL bInitialOwner,
__in_opt  LPCTSTR lpName
);

BOOL WINAPI ReleaseMutex(
__in  HANDLE hMutex
);

（五）各种同步对象的概括





每种同步内核对象都有个OpenXX版本的函数，用来打开已经创建过的对象，如OpenMutex,OpenEvent,

每种创建同步内核对象的函数都有一个对应的后缀为Ex,的版本  如CreateSemaphoreEx，CreateEventEx，  带后缀的版本多了一个__in      DWORD dwDesiredAccess参数，用来设置创建的对象可以用什么访问权限来使用。

每种同步内核对象都是可以具名的，所有的内核对象名字同在一个命名空间内，如果要创建的对象名字已存在，创建函数失败，GetLastError 返回ERROR_ALREADY_EXISTS

每种同步内核对象在不使用的时候都要调用CloseHandle关闭，不然会造成内核对象泄露。

每种同步内核对象都可以拥有不同进程间的线程同步，可以使用DuplicationHandle，句柄继承，打开同名对象的方式，让两个进程中各自的线程引用同一个内核对象来完成同步工作。

（六）其他等待函数

DWORD WaitForInputIdle(
HANDLE hProcess,       // handle to process
DWORD dwMilliseconds   // time-out interval
);

用于等待一个进程，第一次创建窗口。

DWORD WINAPI MsgWaitForMultipleObjects(
__in  DWORD nCount,
__in  const HANDLE *pHandles,
__in  BOOL bWaitAll,
__in  DWORD dwMilliseconds,
__in  DWORD dwWakeMask
);

线程在等待内核对象变为有信号的同时，如果有窗口消息到来，线程也可以变为可调度状态。

BOOL WaitForDebugEvent(
LPDEBUG_EVENT lpDebugEvent,  // debug event information
DWORD dwMilliseconds         // time-out value
);

被调试进程有调试事件时触发，否则一直等待

DWORD WINAPI SignalObjectAndWait(
__in  HANDLE hObjectToSignal,
__in  HANDLE hObjectToWaitOn,
__in  DWORD dwMilliseconds,
__in  BOOL bAlertable
);

将一个对象置为有信号的同时，等待另一个对象，原子操作在内部。