windows线程同步的总结

时间：2021-08-21 17:41:36

http://blog.csdn.net/peter_teng/article/details/11230525

一 线程

1）如果你正在编写C/C++代码，决不应该调用CreateThread。相反，应该使用VisualC++运行期库函数_beginthreadex，退出也应该使用_endthreadex。如果不使用Microsoft的VisualC++编译器，你的编译器供应商有它自己的CreateThred替代函数。不管这个替代函数是什么，你都必须使用。

2）因为_beginthreadex和_endthreadex是CRT线程函数，所以必须注意编译选项runtimelibaray的选择，使用MT或MTD。

3) _beginthreadex函数的参数列表与CreateThread函数的参数列表是相同的，但是参数名和类型并不完全相同。这是因为Microsoft的C/C++运行期库的开发小组认为，C/C++运行期函数不应该对Windows数据类型有任何依赖。_beginthreadex函数也像CreateThread那样，返回新创建的线程的句柄。

4）下面是关于_beginthreadex的一些要点：

•每个线程均获得由C/C++运行期库的堆栈分配的自己的tiddata内存结构。（tiddata结构位于Mtdll.h文件中的VisualC++源代码中）。

•传递给_beginthreadex的线程函数的地址保存在tiddata内存块中。传递给该函数的参数也保存在该数据块中。

•_beginthreadex确实从内部调用CreateThread，因为这是操作系统了解如何创建新线程的唯一方法。

•当调用CreatetThread时，它被告知通过调用_threadstartex而不是pfnStartAddr来启动执行新线程。还有，传递给线程函数的参数是tiddata结构而不是pvParam的地址。

•如果一切顺利，就会像CreateThread那样返回线程句柄。如果任何操作失败了，便返回NULL。

5) _endthreadex的一些要点：

•C运行期库的_getptd函数内部调用操作系统的TlsGetValue函数，该函数负责检索调用线程的tiddata内存块的地址。

•然后该数据块被释放，而操作系统的ExitThread函数被调用，以便真正撤消该线程。当然，退出代码要正确地设置和传递。

6) 虽然也提供了简化版的的_beginthread和_endthread，但是可控制性太差，所以一般不使用。

6）线程handle因为是内核对象，所以需要在最后close handle。

7）C++主线程的终止，同时也会终止所有主线程创建的子线程，不管子线程有没有执行完毕。

8）如果某线程挂起，然后有调用WaitForSingleObject等待该线程，就会导致死锁。

二 线程同步之Critical Sections

1） 因为Critical Sections不是内核对象，所以只能用来同一进程内线程间的同步，不能用来多个不同进程间的线程的同步。

2） 如果在Critical Sections中间突然程序crash或是exit而没有调用LeaveCriticalSection，则结果是该线程所对应的内核不能被释放，该线程成为死线程。

3） 要比其他的内核对象的速度要快。

三 线程同步之Mutex
    
1）互斥对象（mutex）内核对象能够确保线程拥有对单个资源的互斥访问权。实际上互斥对象是因此而得名的。互斥对象包含一个使用数量，一个线程ID和一个递归计数器。
 2） 互斥对象的行为特性与关键代码段相同，但是互斥对象属于内核对象，而关键代码段则属于用户方式对象。这意味着互斥对象的运行速度比关键代码段要慢。但是这也意味着不同进程中的多个线程能够访问单个互斥对象，并且这意味着线程在等待访问资源时可以设定一个超时值。

 3） ID用于标识系统中的哪个线程当前拥有互斥对象，递归计数器用于指明该线程拥有互斥对象的次数。

 4） 互斥对象有许多用途，属于最常用的内核对象之一。通常来说，它们用于保护由多个线程访问的内存块。如果多个线程要同时访问内存块，内存块中的数据就可能遭到破坏。互斥对象能够保证访问内存块的任何线程拥有对该内存块的独占访问权，这样就能够保证数据的完整性。

5）互斥对象的使用规则如下：

• 如果线程ID是0（这是个无效ID），互斥对象不被任何线程所拥有，并且发出该互斥对象的通知信号。

• 如果ID是个非0数字，那么一个线程就拥有互斥对象，并且不发出该互斥对象的通知信号。

• 与所有其他内核对象不同， 互斥对象在操作系统中拥有特殊的代码，允许它们违反正常的规则。


四 线程同步之Event

1）在所有的内核对象中，事件内核对象是个最基本的对象。它们包含一个使用计数（与所有内核对象一样），一个用于指明该事件是个自动重置的事件还是一个人工重置的事件的布尔值，另一个用于指明该事件处于已通知状态还是未通知状态的布尔值。

2）事件能够通知一个操作已经完成。有两种不同类型的事件对象。一种是人工重置的事件，另一种是自动重置的事件。当人工重置的事件得到通知时，等待该事件的所有线程均变为可调度线程。当一个自动重置的事件得到通知时，等待该事件的线程中只有一个线程变为可调度线程。

3）当一个线程执行初始化操作，然后通知另一个线程执行剩余的操作时，事件使用得最多。事件初始化为未通知状态，然后，当该线程完成它的初始化操作后，它就将事件设置为已通知状态。这时，一直在等待该事件的另一个线程发现该事件已经得到通知，因此它就变成可调度线程。

 4）Microsoft为自动重置的事件定义了应该成功等待的副作用规则，即当线程成功地等待到该对象时，自动重置的事件就会自动重置到未通知状态。这就是自动重置的事件如何获得它们的名字的方法。通常没有必要为自动重置的事件调用ResetEvent函数，因为系统会自动对事件进行重置。但是，Microsoft没有为人工重置的事件定义成功等待的副作用，所以需要调用ResetEvent()。

五 线程同步之信号量（Semaphore）

信号量（Semaphore）内核对象对线程的同步方式与前面几种方法不同，它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。在用 CreateSemaphore（）创建信号量时即要同时指出允许的最大资源计数和当前可用资源计数。一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会减1，只要当前可用资源计数是大于0的，就可以发出信号量信号。但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目，不能在允许其他线程的进入，此时的信号量信号将无法发出。线程在处理完共享资源后，应在离开的同时通过 ReleaseSemaphore（）函数将当前可用资源计数加1。在任何时候当前可用资源计数决不可能大于最大资源计数。

使用信号量内核对象进行线程同步主要会用到CreateSemaphore（）、OpenSemaphore（）、ReleaseSemaphore（）、 WaitForSingleObject（）和WaitForMultipleObjects（）等函数。

六 线程同步之其他

1）线程局部存储 （TLS），同一进程中的所有线程共享相同的虚拟地址空间。不同的线程中的局部变量有不同的副本，但是static和globl变量是同一进程中的所有线程共享的。使用TLS技术可以为static和globl的变量，根据当前进程的线程数量创建一个array，每个线程可以通过array的index来访问对应的变量，这样也就保证了static和global的变量为每一个线程都创建不同的副本。

2）互锁函数的家族十分的庞大，例如InterlockedExchangeAdd（）。。。，使用互锁函数的优点是：他的速度要比其他的CriticalSection,Mutex,Event,Semaphore快很多。

3）等待函数，例如WaitForSingleObject 函数用来检测 hHandle 事件的信号状态，当函数的执行时间超过 dwMilliseconds 就返回，但如果参数 dwMilliseconds 为 INFINITE 时函数将直到相应时间事件变成有信号状态才返回，否则就一直等待下去，直到 WaitForSingleObject 有返回直才执行后面的代码。

以下是写的代码

CThread.h

[cpp]  view plain  copy
  1. #include <process.h>  
  2. #include <Windows.h>  
  3.   
  4. //#define  CRITICALSECTION  
  5.   
  6. #define MUTEX  
  7. //#define SEMAPHORE  
  8. #define EVENT  
  9.   
  10. #ifdef CRITICALSECTION  
  11.   
  12. class CriticalSection  
  13. {  
  14. public:  
  15.     CriticalSection(){ InitializeCriticalSection(&criticalS); }  
  16.     ~CriticalSection(){ DeleteCriticalSection(&criticalS); }  
  17.     void enterCriticalSection(){ EnterCriticalSection(&criticalS); }  
  18.     void leaveCriticalSection(){ LeaveCriticalSection(&criticalS);}  
  19. private:  
  20.     CRITICAL_SECTION criticalS;  
  21. };  
  22.   
  23. class CLock  
  24. {  
  25. public:  
  26.     CLock(CriticalSection *crs):cs(crs){lock();}  
  27.     ~CLock(){unlock();}  
  28.     void lock(){ cs->enterCriticalSection() ;}  
  29.     void unlock(){ cs->leaveCriticalSection(); }  
  30.   
  31. private:  
  32.     CriticalSection *cs;   
  33. };  
  34.   
  35. #endif  

CThread.cpp

[cpp]  view plain  copy
  1. // CThread.cpp : Defines the entry point for the console application.  
  2. //  
  3.   
  4. #include "stdafx.h"  
  5. #include "CThread.h"  
  6. //#include <Windows.h>  
  7.   
  8. #define MAX1 1  
  9. #define MAX2 10  
  10.   
  11. #define INITRESOURCE 10  
  12. #define MAXRESOURCE 10  
  13.   
  14. #define THREADNUM 5  
  15.   
  16. #define Thread __declspec(thread)  
  17.   
  18. Thread static int g_tls = 0;  
  19.   
  20. int g_count = 0;  
  21.   
  22. #ifdef CRITICALSECTION  
  23.     CriticalSection critSct;  
  24. #endif  
  25.   
  26. #ifdef MUTEX  
  27.     HANDLE g_mutex;  
  28. #endif  
  29.   
  30. #ifdef SEMAPHORE   
  31.     HANDLE g_semaphore;  
  32. #endif  
  33.   
  34. #ifdef EVENT  
  35.     HANDLE g_event;  
  36. #endif  
  37.   
  38. unsigned _stdcall thread1Entry(void *pList)  
  39. {  
  40. #ifdef CRITICALSECTION  
  41.     CLock myLock(&critSct);  
  42. #endif  
  43.       
  44. #ifdef SEMAPHORE  
  45.     WaitForSingleObject(g_semaphore, INFINITE);  
  46. #endif  
  47.   
  48. #ifdef MUTEX  
  49.     WaitForSingleObject(g_mutex, INFINITE);  
  50. #endif  
  51.   
  52. #ifdef EVENT  
  53.     WaitForSingleObject(g_event, INFINITE);  
  54. #endif  
  55.   
  56.     for( int i = 0; i < MAX1; i++)  
  57.     {  
  58.         g_count++;  
  59.         printf("threa1:%d\n",g_count);  
  60.     }  
  61. #ifdef EVENT  
  62.     SetEvent(g_event);  
  63. #endif  
  64.     //if( g_count == 100 )  
  65.     //{  
  66.         //long preciousCount = 0;  
  67.         //ReleaseSemaphore(g_semaphore, 2, &preciousCount);  
  68.         //printf("thread precious count is:%d\n", preciousCount);  
  69.     //}  
  70.     return 0;  
  71.   
  72. }  
  73.   
  74. unsigned _stdcall thread2Entry(void *pList)  
  75. {  
  76. #ifdef CRITICALSECTION  
  77.         CLock myLock(&critSct);  
  78. #endif  
  79.   
  80. #ifdef MUTEX  
  81.         WaitForSingleObject(g_mutex, INFINITE);  
  82. #endif  
  83.   
  84. #ifdef EVENT  
  85.         WaitForSingleObject(g_event, INFINITE);  
  86. #endif  
  87.   
  88.     for( int i = MAX1; i < MAX2; i++)  
  89.     {  
  90.         g_count++;  
  91.         printf("threa2:%d\n",g_count);  
  92.     }  
  93.   
  94. #ifdef EVENT  
  95.     SetEvent(g_event);  
  96. #endif  
  97.   
  98.     return 0;  
  99. }  
  100.   
  101. void loadDataIntoMemory()  
  102. {  
  103.     printf("load data into memory!\n");  
  104. }  
  105.   
  106. int _tmain(int argc, _TCHAR* argv[])  
  107. {  
  108. #ifdef MUTEX  
  109.     g_mutex = CreateMutex(NULL, false, NULL);  
  110.     if( g_mutex == NULL )  
  111.     {  
  112.         printf("create mutex failed with error %d\n", GetLastError());  
  113.         return 1;  
  114.     }  
  115. #endif  
  116.   
  117. #ifdef SEMAPHORE  
  118.     g_semaphore = CreateSemaphore(NULL, INITRESOURCE, MAXRESOURCE, NULL);  
  119. #endif  
  120.   
  121. #ifdef EVENT  
  122.     g_event = CreateEvent(NULL, false, false, NULL);  
  123. #endif  
  124.   
  125.     HANDLE thread[THREADNUM + 1];  
  126.   
  127.     for( int i = 0; i < THREADNUM; i++ )  
  128.     {  
  129.         thread[i] = (HANDLE)_beginthreadex(NULL, 0, thread1Entry, NULL, 0, NULL);  
  130.         if( thread[i] == NULL )  
  131.         {  
  132.             printf("create thread failed with error %d\n", GetLastError());  
  133.             return 1;  
  134.         }  
  135.     }  
  136.   
  137. #ifdef EVENT  
  138.     thread[5] = (HANDLE)_beginthreadex(NULL, 0, thread2Entry, NULL, 0, NULL);  
  139.   
  140.     loadDataIntoMemory();  
  141.   
  142.     SetEvent(g_event);  
  143. #endif  
  144.   
  145.     WaitForMultipleObjects(THREADNUM, thread, true, INFINITE);  
  146.   
  147.     for( int i = 0; i < THREADNUM; i++ )  
  148.     {  
  149.         CloseHandle(thread[i]);  
  150.     }  
  151.   
  152. #ifdef MUTEX  
  153.         ReleaseMutex(g_mutex);  
  154. #endif  
  155.   
  156. #ifdef SEMAPHORE  
  157.         long preciousCount = 0;  
  158.         ReleaseSemaphore(g_semaphore, 0, &preciousCount);  
  159.         printf("precious count is:%d\n", preciousCount);  
  160. #endif  
  161.   
  162.     return 0;  
  163. }  
windows线程同步的总结


标签：

相关文章