4一个经典的多线程同步问题.docx

《4一个经典的多线程同步问题.docx》由会员分享，可在线阅读，更多相关《4一个经典的多线程同步问题.docx（25页珍藏版）》请在三一办公上搜索。

1、4一个经典的多线程同步问题一个经典的多线程同步问题 程序描述： 主线程启动10个子线程并将表示子线程序号的变量地址作为参数传递给子线程。子线程接收参数 - sleep(50) - 全局变量+ - sleep(0) - 输出参数和全局变量。 要求： 1子线程输出的线程序号不能重复。 2全局变量的输出必须递增。 下面画了个简单的示意图： 分析下这个问题的考察点，主要考察点有二个： 1主线程创建子线程并传入一个指向变量地址的指针作参数，由于线程启动须要花费一定的时间，所以在子线程根据这个指针访问并保存数据前，主线程应等待子线程保存完毕后才能改动该参数并启动下一个线程。这涉及到主线程与子线程之间的同步

2、。 2子线程之间会互斥的改动和输出全局变量。要求全局变量的输出必须递增。这涉及到各子线程间的互斥。 下面列出这个程序的基本框架，可以在此代码基础上进行修改和验证。 /经典线程同步互斥问题 #include #include #include long g_nNum; /全局资源 unsigned int _stdcall Fun(void *pPM); /线程函数 const int THREAD_NUM = 10; /子线程个数 int main g_nNum = 0; HANDLE handleTHREAD_NUM; int i = 0; while (i THREAD_NUM) /保证子

3、线程已全部运行结束 WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE); return 0; handlei = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL); i+;/等子线程接收到参数时主线程可能改变了这个i的值 unsigned int _stdcall Fun(void *pPM) 运行结果： /由于创建线程是要一定的开销的，所以新线程并不能第一时间执行到这来 int nThreadNum = *(int *)pPM; /子线程获取参数 Sleep(50);/some

4、 work should to do g_nNum+; /处理全局资源 Sleep(0);/some work should to do printf(线程编号为%d 全局资源值为%dn, nThreadNum, g_nNum); return 0; 可以看出，运行结果完全是混乱和不可预知的。运用Windows平台下各种手段包括关键段，事件，互斥量，信号量等等来解决这个问题。 关键段CRITICAL_SECTION 首先介绍下如何使用关键段，然后再深层次的分析下关键段的实现机制与原理。 关键段CRITICAL_SECTION一共就四个函数，使用很是方便。下面是这四个函数的原型和使用说明。 函数

5、功能：初始化 函数原型： void InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection); 函数说明：定义关键段变量后必须先初始化。 函数功能：销毁 函数原型： void DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection); 函数说明：用完之后记得销毁。 函数功能：进入关键区域 函数原型： void EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection); 函数说明：系统保证各线程互斥的进入关

6、键区域。 函数功能：离开关关键区域 函数原型： void LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection); 然后在经典多线程问题中设置二个关键区域。一个是主线程在递增子线程序号时，另一个是各子线程互斥的访问输出全局资源时。详见代码： #include #include #include long g_nNum; unsigned int _stdcall Fun(void *pPM); const int THREAD_NUM = 10; /关键段变量声明 CRITICAL_SECTION g_csThreadParamet

7、er, g_csThreadCode; int main unsigned int _stdcall Fun(void *pPM) EnterCriticalSection(&g_csThreadCode);/进入各子线程互斥区域 g_nNum+; Sleep(0);/some work should to do printf(线程编号为%d 全局资源值为%dn, nThreadNum, g_nNum); Sleep(50);/some work should to do int nThreadNum = *(int *)pPM; LeaveCriticalSection(&g_csThrea

8、dParameter);/离开子线程序号关键区域 DeleteCriticalSection(&g_csThreadCode); DeleteCriticalSection(&g_csThreadParameter); return 0; HANDLE handleTHREAD_NUM; g_nNum = 0; int i = 0; while (i UniqueThread HANDLE LockSemaphore; DWORD SpinCount; RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION; 各个参数的解释如下： 第一个参数：PRTL_CRI

9、TICAL_SECTION_DEBUGDebugInfo; 调试用的。 第二个参数：LONG LockCount; 初始化为-1，n表示有n个线程在等待。 第三个参数：LONG RecursionCount; 表示该关键段的拥有线程对此资源获得关键段次数，初为0。 第四个参数：HANDLE OwningThread; 即拥有该关键段的线程句柄，微软对其注释为from the threads ClientId-UniqueThread 第五个参数：HANDLELockSemaphore; 实际上是一个自复位事件。 第六个参数：DWORDSpinCount; 旋转锁的设置，单CPU下忽略 由这个结

10、构可以知道关键段会记录拥有该关键段的线程句柄即关键段是有“线程所有权”概念的。事实上它会用第四个参数OwningThread来记录获准进入关键区域的线程句柄，如果这个线程再次进入，EnterCriticalSection会更新第三个参数RecursionCount以记录该线程进入的次数并立即返回让该线程进入。其它线程调用EnterCriticalSection则会被切换到等待状态，一旦拥有线程所有权的线程调用LeaveCriticalSection使其进入的次数为0时，系统会自动更新关键段并将等待中的线程换回可调度状态。 因此可以将关键段比作旅馆的房卡，调用EnterCriticalSecti

11、on即申请房卡，得到房卡后自己当然是可以多次进出房间的，在你调用LeaveCriticalSection交出房卡之前，别人自然是无法进入该房间。 回到这个经典线程同步问题上，主线程正是由于拥有“线程所有权”即房卡，所以它可以重复进入关键代码区域从而导致子线程在接收参数之前主线程就已经修改了这个参数。所以关键段可以用于线程间的互斥，但不可以用于同步。 另外，由于将线程切换到等待状态的开销较大，因此为了提高关键段的性能，Microsoft将旋转锁合并到关键段中，这样EnterCriticalSection会先用一个旋转锁不断循环，尝试一段时间才会将线程切换到等待状态。下面是配合了旋转锁的关键段初始

12、化函数 函数功能：初始化关键段并设置旋转次数 函数原型： BOOL InitializeCriticalSectionAndSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount); 函数说明：旋转次数一般设置为4000。 函数功能：修改关键段的旋转次数 函数原型： DWORD SetCriticalSectionSpinCount( LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount); Windows核心编程第五版的第八章推荐在使用关键段的时候同时使用旋

13、转锁，这样有助于提高性能。值得注意的是如果主机只有一个处理器，那么设置旋转锁是无效的。无法进入关键区域的线程总会被系统将其切换到等待状态。 最后总结下关键段： 1关键段共初始化化、销毁、进入和离开关键区域四个函数。 2关键段可以解决线程的互斥问题，但因为具有“线程所有权”，所以无法解决同步问题。 3推荐关键段与旋转锁配合使用。 事件Event 使用关键段来解决经典的多线程同步互斥问题，由于关键段的“线程所有权”特性所以关键段只能用于线程的互斥而不能用于同步。本篇介绍用事件Event来尝试解决这个线程同步问题。 首先介绍下如何使用事件。事件Event实际上是个内核对象，它的使用非常方便。下面列出

14、一些常用的函数。 第一个 CreateEvent 函数功能：创建事件 函数原型： HANDLE CreateEvent( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCTSTR lpName ); 函数说明： 第一个参数表示安全控制，一般直接传入NULL。 第二个参数确定事件是手动置位还是自动置位，传入TRUE表示手动置位，传入FALSE表示自动置位。如果为自动置位，则对该事件调用WaitForSingleObject后会自动调用ResetEvent使事件变成未触发状态。打个

15、小小比方，手动置位事件相当于教室门，教室门一旦打开，所以有人都可以进入直到老师去关上教室门。自动置位事件就相当于医院里拍X光的房间门，门打开后只能进入一个人，这个人进去后会将门关上，其它人不能进入除非门重新被打开。 第三个参数表示事件的初始状态，传入TRUR表示已触发。 第四个参数表示事件的名称，传入NULL表示匿名事件。 第二个 OpenEvent 函数功能：根据名称获得一个事件句柄。 函数原型： HANDLE OpenEvent( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCTSTR lpName /名称 ); 函数说明： 第一个参数表示访

16、问权限，对事件一般传入EVENT_ALL_ACCESS。详细解释可以查看MSDN文档。 第二个参数表示事件句柄继承性，一般传入TRUE即可。 第三个参数表示名称，不同进程中的各线程可以通过名称来确保它们访问同一个事件。 第三个SetEvent 函数功能：触发事件 函数原型：BOOL SetEvent(HANDLEhEvent); 函数说明：每次触发后，必有一个或多个处于等待状态下的线程变成可调度状态。 第四个ResetEvent 函数功能：将事件设为末触发 函数原型：BOOL ResetEvent(HANDLEhEvent); 最后一个事件的清理与销毁 由于事件是内核对象，因此使用CloseH

17、andle就可以完成清理与销毁了。 在经典多线程问题中设置一个事件和一个关键段。用事件处理主线程与子线程的同步，用关键段来处理各子线程间的互斥。详见代码： #include #include #include long g_nNum; unsigned int _stdcall Fun(void *pPM); const int THREAD_NUM = 10; /事件与关键段 HANDLE g_hThreadEvent; CRITICAL_SECTION g_csThreadCode; int main unsigned int _stdcall Fun(void *pPM) /销毁事件和关

18、键段 CloseHandle(g_hThreadEvent); DeleteCriticalSection(&g_csThreadCode); return 0; WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE); ResetEvent(g_hThreadEvent); WaitForSingleObject(g_hThreadEvent, INFINITE); /等待事件被触发 i+; HANDLE handleTHREAD_NUM; g_nNum = 0; int i = 0; while (i THREAD_NUM) h

19、andlei = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL); /初始化事件和关键段自动置位,初始无触发的匿名事件 g_hThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL); InitializeCriticalSection(&g_csThreadCode); printf(经典线程同步事件Eventn); int nThreadNum = *(int *)pPM; /SetEvent(g_hThreadEvent); /触发事件 Sleep(50);/some work should

20、 to do EnterCriticalSection(&g_csThreadCode); g_nNum+; Sleep(0);/some work should to do printf(线程编号为%d 全局资源值为%dn, nThreadNum, g_nNum); LeaveCriticalSection(&g_csThreadCode); SetEvent(g_hThreadEvent); return 0; 运行结果： 可以看出来，经典线线程同步问题已经圆满的解决了线程编号的输出没有重复，说明主线程与子线程达到了同步。全局资源的输出是递增的，说明各子线程已经互斥的访问和输出该全局资源。

21、 现在我们知道了如何使用事件，但学习就应该要深入的学习，何况微软给事件还提供了PulseEvent函数，所以接下来再继续深挖下事件Event，看看它还有什么秘密没。 先来看看这个函数的原形： 第五个PulseEvent 函数功能：将事件触发后立即将事件设置为未触发，相当于触发一个事件脉冲。 函数原型：BOOL PulseEvent(HANDLEhEvent); 函数说明：这是一个不常用的事件函数，此函数相当于SetEvent后立即调用ResetEvent;此时情况可以分为两种： 1.对于手动置位事件，所有正处于等待状态下线程都变成可调度状态。 2.对于自动置位事件，所有正处于等待状态下线程只有

22、一个变成可调度状态。 此后事件是末触发的。该函数不稳定，因为无法预知在调用PulseEvent 时哪些线程正处于等待状态。 下面对这个触发一个事件脉冲PulseEvent 写一个例子，主线程启动7个子线程，其中有5个线程Sleep(10)后对一事件调用等待函数，另有2个线程Sleep(100)后也对该事件调用等待函数。主线程启动所有子线程后再Sleep(50)保证有5个快线程都正处于等待状态中。此时若主线程触发一个事件脉冲，那么对于手动置位事件，这5个线程都将顺利执行下去。对于自动置位事件，这5个线程中会有中一个顺利执行下去。而不论手动置位事件还是自动置位事件，那2个慢线程由于Sleep(10

23、0)所以会错过事件脉冲，因此慢线程都会进入等待状态而无法顺利执行下去。 代码如下： /使用PluseEvent函数 #include #include #include #include HANDLE g_hThreadEvent; /快线程 unsigned int _stdcall FastThreadFun(void *pPM) /慢线程 unsigned int _stdcall SlowThreadFun(void *pPM) int main /创建事件第二个参数手动置位TRUE，自动置位FALSE g_hThreadEvent = CreateEvent(NULL, bManua

24、lReset, FALSE, NULL); BOOL bManualReset = FALSE; printf(使用PluseEvent函数n); Sleep(100); printf(%s 启动n, (PSTR)pPM); WaitForSingleObject(g_hThreadEvent, INFINITE); printf(%s 等到事件被触发顺利结束n, (PSTR)pPM); return 0; Sleep(10); /用这个来保证各线程调用等待函数的次序有一定的随机性 printf(%s 启动n, (PSTR)pPM); WaitForSingleObject(g_hThread

25、Event, INFINITE); printf(%s 等到事件被触发顺利结束n, (PSTR)pPM); return 0; 运行结果： Sleep(3000); printf(时间到，主线程结束运行n); CloseHandle(g_hThreadEvent); return 0; Sleep(50); /保证快线程已经全部启动 printf(现在主线程触发一个事件脉冲- PulseEventn); PulseEvent(g_hThreadEvent);/调用PulseEvent就相当于同时调用下面二句 /SetEvent(g_hThreadEvent); /ResetEvent(g_hT

26、hreadEvent); int i; for (i = 0; i 5; i+) _beginthreadex(NULL, 0, FastThreadFun, szFastThreadNamei, 0, NULL); _beginthreadex(NULL, 0, SlowThreadFun, szSlowThreadNamei, 0, NULL); for (i = 0; i 2; i+) char szFastThreadName530 = 快线程, 快线程, 快线程, 快线程, 快线程; char szSlowThreadName230 = 慢线程, 慢线程; if (bManualRe

27、set = TRUE) printf(当前使用手动置位事件n); printf(当前使用自动置位事件n); else 手动置位代码 int main BOOL bManualReset = TRUE; printf(使用PluseEvent函数n); Sleep(3000); printf(时间到，主线程结束运行n); CloseHandle(g_hThreadEvent); return 0; Sleep(50); /保证快线程已经全部启动 printf(现在主线程触发一个事件脉冲- PulseEventn); /PulseEvent(g_hThreadEvent);/调用PulseEven

28、t就相当于同时调用下面二句 SetEvent(g_hThreadEvent); ResetEvent(g_hThreadEvent); int i; for (i = 0; i 5; i+) _beginthreadex(NULL, 0, FastThreadFun, szFastThreadNamei, 0, NULL); _beginthreadex(NULL, 0, SlowThreadFun, szSlowThreadNamei, 0, NULL); for (i = 0; i 2; i+) char szFastThreadName530 = 快线程, 快线程, 快线程, 快线程,

29、快线程; char szSlowThreadName230 = 慢线程, 慢线程; if (bManualReset = TRUE) printf(当前使用手动置位事件n); printf(当前使用自动置位事件n); else /创建事件第二个参数手动置位TRUE，自动置位FALSE g_hThreadEvent = CreateEvent(NULL, bManualReset, FALSE, NULL); 最后总结下事件Event 1事件是内核对象，事件分为手动置位事件和自动置位事件。事件Event内部它包含一个使用计数，一个布尔值表示是手动置位事件还是自动置位事件，另一个布尔值用来表示事件

30、有无触发。 2事件可以由SetEvent来触发，由ResetEvent来设成未触发。还可以由PulseEvent来发出一个事件脉冲。 3事件可以解决线程间同步问题，因此也能解决互斥问题。 互斥量Mutex 前面介绍了关键段CS、事件Event在经典线程同步问题中的使用。本篇介绍用互斥量Mutex来解决这个问题。 互斥量也是一个内核对象，它用来确保一个线程独占一个资源的访问。互斥量与关键段的行为非常相似，并且互斥量可以用于不同进程中的线程互斥访问资源。使用互斥量Mutex主要将用到四个函数。下面是这些函数的原型和使用说明。 第一个 CreateMutex 函数功能：创建互斥量 函数原型： HAN

31、DLE CreateMutex( LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCTSTR lpName ); 函数说明： 第一个参数表示安全控制，一般直接传入NULL。 第二个参数用来确定互斥量的初始拥有者。如果传入TRUE表示互斥量对象内部会记录创建它的线程的线程ID号并将递归计数设置为1，由于该线程ID非零，所以互斥量处于未触发状态。如果传入FALSE，那么互斥量对象内部的线程ID号将设置为NULL，递归计数设置为0，这意味互斥量不为任何线程占用，处于触发状态。 第三个参数用来设置互斥量的名称，在多个进程中的

32、线程就是通过名称来确保它们访问的是同一个互斥量。 函数访问值： 成功返回一个表示互斥量的句柄，失败返回NULL。 第二个打开互斥量 函数原型： HANDLE OpenMutex( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCTSTR lpName /名称 ); 函数说明： 第一个参数表示访问权限，对互斥量一般传入MUTEX_ALL_ACCESS。详细解释可以查看MSDN文档。 第二个参数表示互斥量句柄继承性，一般传入TRUE即可。 第三个参数表示名称。某一个进程中的线程创建互斥量后，其它进程中的线程就可以通过这个函数来找到这个互斥量。 函数访问

33、值： 成功返回一个表示互斥量的句柄，失败返回NULL。 第三个触发互斥量 函数原型： BOOLReleaseMutex (HANDLEhMutex) 函数说明： 访问互斥资源前应该要调用等待函数，结束访问时就要调用ReleaseMutex来表示自己已经结束访问，其它线程可以开始访问了。 最后一个清理互斥量 由于互斥量是内核对象，因此使用CloseHandle就可以。 接下来我们就在经典多线程问题用互斥量来保证主线程与子线程之间的同步，由于互斥量的使用函数类似于事件Event，所以可以仿照上一篇的实现来写出代码： /经典线程同步问题互斥量Mutex #include #include #incl

34、ude long g_nNum; unsigned int _stdcall Fun(void *pPM); const int THREAD_NUM = 10; /互斥量与关键段 HANDLE g_hThreadParameter; CRITICAL_SECTION g_csThreadCode; int main HANDLE handleTHREAD_NUM; g_nNum = 0; int i = 0; while (i THREAD_NUM) /初始化互斥量与关键段第二个参数为TRUE表示互斥量为创建线程所有 g_hThreadParameter = CreateMutex(NULL

35、, FALSE, NULL); InitializeCriticalSection(&g_csThreadCode); printf(经典线程同步-互斥量Mutexn); handlei = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL); WaitForSingleObject(g_hThreadParameter, INFINITE); /等待互斥量被触发 i+; WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE); /销毁互斥量和关键段 CloseHandle(g_hTh

36、readParameter); DeleteCriticalSection(&g_csThreadCode); for (i = 0; i THREAD_NUM; i+) CloseHandle(handlei); return 0; unsigned int _stdcall Fun(void *pPM) 运行结果： EnterCriticalSection(&g_csThreadCode); g_nNum+; Sleep(0);/some work should to do printf(线程编号为%d 全局资源值为%dn, nThreadNum, g_nNum); LeaveCritic

37、alSection(&g_csThreadCode); return 0; Sleep(50);/some work should to do int nThreadNum = *(int *)pPM; ReleaseMutex(g_hThreadParameter);/触发互斥量 可以看出，与关键段类似，互斥量也是不能解决线程间的同步问题。 联想到关键段会记录线程ID即有“线程拥有权”的，而互斥量也记录线程ID，莫非它也有“线程拥有权”这一说法。 答案确实如此，互斥量也是有“线程拥有权”概念的。“线程拥有权”在关键段中有详细的说明，这里就不再赘述了。另外由于互斥量常用于多进程之间的线程互斥，

38、所以它比关键段还多一个很有用的特性“遗弃”情况的处理。比如有一个占用互斥量的线程在调用ReleaseMutex触发互斥量前就意外终止了，那么所有等待这个互斥量的线程是否会由于该互斥量无法被触发而陷入一个无穷的等待过程中了？这显然不合理。因为占用某个互斥量的线程既然终止了那足以证明它不再使用被该互斥量保护的资源，所以这些资源完全并且应当被其它线程来使用。因此在这种“遗弃”情况下，系统自动把该互斥量内部的线程ID设置为0，并将它的递归计数器复置为0，表示这个互斥量被触发了。然后系统将“公平地”选定一个等待线程来完成调度。 下面写二个程序来验证下： 第一个程序创建互斥量并等待用户输入后就触发互斥量。

39、第二个程序先打开互斥量，成功后就等待并根据等待结果作相应的输出。详见代码： 第一个程序： #include #include #include const char MUTEX_NAME = Mutex_MoreWindows; int main HANDLE hMutex = CreateMutex(NULL, TRUE, MUTEX_NAME); /创建互斥量 printf(互斥量已经创建，现在按任意键触发互斥量n); getch; /exit(0); ReleaseMutex(hMutex); printf(互斥量已经触发n); CloseHandle(hMutex); return 0

40、; 第二个程序： #include #include const char MUTEX_NAME = Mutex_MoreWindows; int main HANDLE hMutex = OpenMutex(MUTEX_ALL_ACCESS, TRUE, MUTEX_NAME); /打开互斥量 if (hMutex = NULL) printf(打开互斥量失败n); return 0; printf(等待中.n); DWORD dwResult = WaitForSingleObject(hMutex, 20 * 1000); /等待互斥量被触发 switch (dwResult) case

41、 WAIT_ABANDONED: printf(拥有互斥量的进程意外终止n); break; case WAIT_OBJECT_0: printf(已经收到信号n); break; case WAIT_TIMEOUT: CloseHandle(hMutex); return 0; printf(信号未在规定的时间内送到n); break; 运用这二个程序时要先启动程序一再启动程序二。下面展示部分输出结果： 结果一二个进程顺利执行完毕： 结果二将程序一中/exit(0);前面的注释符号去掉，这样程序一在触发互斥量之前就会因为执行exit(0);语句而且退出，程序二会收到WAIT_ABANDONED消息并输出“拥有互斥量的进程意外终止”： 有这个对“遗弃”问题的处理，在多进程中的线程同步也可以放心的使用互斥量。 最后总结下互斥量Mutex： 1互斥量是内核对象，它与关键段都有“线程所有权”所以不能用于线程的同步。 2互斥量能够用于多个进程之间线程互斥问题，并且能完美的解决某进程意外终止所造成的