秒杀多线程第八篇 经典线程同步 信号量Semaphore

转载出处：秒杀多线程第八篇 经典线程同步 信号量Semaphore

学习笔记：

看了一下作者写的列子，下面写一下自己的理解。代码部分如下：

步，用关键段来处理各子线程间的互斥。详见代码：

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <process.h>  
3. #include <windows.h>  
4. long g_nNum;  
5. unsigned int __stdcall Fun(void *pPM);  
6. const int THREAD_NUM = 10;  
7. //信号量与关键段  
8. HANDLE            g_hThreadParameter;  
9. CRITICAL_SECTION  g_csThreadCode;  
10. int main()  
11. {  
12.     printf("     经典线程同步 信号量Semaphore\n");  
13.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
14.   
15.     //初始化信号量和关键段  
16.     g_hThreadParameter = CreateSemaphore(NULL, 0, 1, NULL);//当前0个资源，最大允许1个同时访问  
17. //创建信号量这个函数在传入的第二和第三个参数是很重要的，必须明确要传入的值。
18. //第二个参数表示当前资源的个数，如果传入0，那么下面的WaitForSingleObject就会阻塞等待资源个数大于0，如   果初始化大于0的话WaitForSingleObject将不会阻塞等待，那么信号量的作用在此处就失去了意义。
19. //第三个参数表示最大的并发数量
20.     InitializeCriticalSection(&g_csThreadCode);  
21.   
22.     HANDLE  handle[THREAD_NUM];   
23.     g_nNum = 0;  
24.     int i = 0;  
25.     while (i < THREAD_NUM)   
26.     {  
27.         handle[i] = (HANDLE)_beginthreadex(NULL, 0, Fun, &i, 0, NULL);  
28.         WaitForSingleObject(g_hThreadParameter, INFINITE);//等待信号量>0，会对资源计数做--操作 
29.         ++i;  
30.     }  
31.     WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);  
32.       
33.     //销毁信号量和关键段  
34.     DeleteCriticalSection(&g_csThreadCode);  
35.     CloseHandle(g_hThreadParameter);  
36.     for (i = 0; i < THREAD_NUM; i++)  
37.         CloseHandle(handle[i]);  
38.     return 0;  
39. }  
40. unsigned int __stdcall Fun(void *pPM)  
41. {  
42.     int nThreadNum = *(int *)pPM;  
43.     ReleaseSemaphore(g_hThreadParameter, 1, NULL);//触发，对资源计数做++操作  
44.   
45.     Sleep(50);//some work should to do  
46.   
47.     EnterCriticalSection(&g_csThreadCode);  
48.     ++g_nNum;  
49.     Sleep(0);//some work should to do  
50.     printf("线程编号为%d  全局资源值为%d\n", nThreadNum, g_nNum);  
51.     LeaveCriticalSection(&g_csThreadCode);  
52.     return 0;  
53. }  

有上可知，当程序_beginthreadex第一个线程的后，由于初始化资源个数为0，所以WaitForSingleObject将等待资源个数大于0，即等待信号量触发（ReleaseSemaphore）对资源计数++，然后才做第二次_beginthreadex，这样就达到了同步的效果。