VC++ 线程同步 总结

Posted 2020-07-05 车臣

注:所谓同步，并不是多个线程一起同时执行，而是他们协同步调，按预定的先后次序执行。

 

与线程相关的基本函数包括：
CreateThread：创建线程
CloseHandle：关闭线程句柄。注意，这只会使指定的线程句柄无效（减少该句柄的引用计数），启动句柄的检查操作，如果一个对象所关联的最后一个句柄被关闭了，那么这个对象会从系统中被删除。关闭句柄不会终止相关的线程。

 

线程是如何运行的呢？这又与你的CPU有关系了，如果你是一个单核CPU，那么系统会采用时间片轮询的方式运行每个线程；如果你是多核CPU，那么线程之间就有可能并发运行了。这样就会出现很多问题，比如两个线程同时访问一个全局变量之类的。它们需要线程的同步来解决。所谓同步，并不是多个线程一起同时执行，而是他们协同步调，按预定的先后次序执行。
Windows下线程同步的基本方法有3种：互斥对象、事件对象、关键代码段（临界区），下面一一介绍：

 

互斥对象属于内核对象，包含3个成员：
1.使用数量：记录了有多少个线程在调用该对象
2.一个线程ID：记录互斥对象维护的线程的ID
3.一个计数器：前线程调用该对象的次数
与之相关的函数包括：
创建互斥对象：CreateMutex
判断能否获得互斥对象：WaitForSingleObject
对于WaitForSingleObject，如果互斥对象为有信号状态，则获取成功，函数将互斥对象设置为无信号状态，程序将继续往下执行；如果互斥对象为无信号状态，则获取失败，线程会停留在这里等待。等待的时间可以由参数控制。
释放互斥对象：ReleaseMutex
当要保护的代码执行完毕后，通过它来释放互斥对象，使得互斥对象变为有信号状态，以便于其他线程可以获取这个互斥对象。注意，只有当某个线程拥有互斥对象时，才能够释放互斥对象，在其他线程调用这个函数不得达到释放的效果，这可以通过互斥对象的线程ID来判断。

 1 #include <Windows.h>
 2 #include <stdio.h>
 3 
 4 //线程函数声明
 5 DWORD WINAPI Thread1Proc(  LPVOID lpParameter);
 6 DWORD WINAPI Thread2Proc(  LPVOID lpParameter);
 7 
 8 //全局变量
 9 int tickets = 100;
10 HANDLE hMutex;
11 
12 int main()
13 {
14     HANDLE hThread1;
15     HANDLE hThread2;
16     //创建互斥对象
17     hMutex = CreateMutex( NULL,            //默认安全级别
18                           FALSE,        //创建它的线程不拥有互斥对象
19                           NULL);        //没有名字
20     //创建线程1
21     hThread1 = CreateThread(NULL,        //默认安全级别
22                             0,            //默认栈大小
23                             Thread1Proc,//线程函数 
24                             NULL,        //函数没有参数
25                             0,            //创建后直接运行
26                             NULL);        //线程标识，不需要
27 
28     //创建线程2
29     hThread2 = CreateThread(NULL,        //默认安全级别
30                             0,            //默认栈大小
31                             Thread2Proc,//线程函数 
32                             NULL,        //函数没有参数
33                             0,            //创建后直接运行
34                             NULL);        //线程标识，不需要
35 
36     //主线程休眠4秒
37     Sleep(4000);
38     //主线程休眠4秒
39     Sleep(4000);
40     //关闭线程句柄
41     CloseHandle(hThread1);
42     CloseHandle(hThread2);
43 
44     //释放互斥对象
45     ReleaseMutex(hMutex);
46     return 0;
47 }
48 
49 //线程1入口函数
50 DWORD WINAPI Thread1Proc(  LPVOID lpParameter)
51 {
52     while(TRUE)
53     {
54         WaitForSingleObject(hMutex,INFINITE);
55         if(tickets > 0)
56         {
57             Sleep(10);
58             printf("thread1 sell ticket : %d\n",tickets--);
59             ReleaseMutex(hMutex);
60         }
61         else
62         {
63             ReleaseMutex(hMutex);
64             break;
65         }
66     }
67 
68     return 0;
69 }
70 
71 //线程2入口函数
72 DWORD WINAPI Thread2Proc(  LPVOID lpParameter)
73 {
74     while(TRUE)
75     {
76         WaitForSingleObject(hMutex,INFINITE);
77         if(tickets > 0)
78         {
79             Sleep(10);
80             printf("thread2 sell ticket : %d\n",tickets--);
81             ReleaseMutex(hMutex);
82         }
83         else
84         {
85             ReleaseMutex(hMutex);
86             break;
87         }
88     }
89 
90     return 0;
91 }

1 使用互斥对象时需要小心：
2 调用假如一个线程本身已经拥有该互斥对象，则如果它继续调用WaitForSingleObject，则会增加互斥对象的引用计数，此时，你必须多次调用ReleaseMutex来释放互斥对象，以便让其他线程可以获取：

1     //创建互斥对象
2     hMutex = CreateMutex( NULL,            //默认安全级别
3                           TRUE,            //创建它的线程拥有互斥对象
4                           NULL);        //没有名字
5     WaitForSingleObject(hMutex,INFINITE);
6     //释放互斥对象
7     ReleaseMutex(hMutex);
8     //释放互斥对象
9     ReleaseMutex(hMutex);

下面看事件对象，它也属于内核对象，包含3各成员：
1.使用计数
2.用于指明该事件是自动重置事件还是人工重置事件的布尔值
3.用于指明该事件处于已通知状态还是未通知状态。
自动重置和人工重置的事件对象有一个重要的区别：当人工重置的事件对象得到通知时，等待该事件对象的所有线程均变为可调度线程；而当一个自动重置的事件对象得到通知时，等待该事件对象的线程中只有一个线程变为可调度线程。
与事件对象相关的函数包括：
创建事件对象：CreateEvent
HANDLE CreateEvent(  LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState,LPCTSTR lpName);
设置事件对象：SetEvent：将一个这件对象设为有信号状态
BOOL SetEvent(  HANDLE hEvent  );
重置事件对象状态：ResetEvent：将指定的事件对象设为无信号状态
BOOL ResetEvent(  HANDLE hEvent );

 

下面仍然使用买火车票的例子：

 1 #include <Windows.h>
 2 #include <stdio.h>
 3 
 4 //线程函数声明
 5 DWORD WINAPI Thread1Proc(  LPVOID lpParameter);
 6 DWORD WINAPI Thread2Proc(  LPVOID lpParameter);
 7 
 8 //全局变量
 9 int tickets = 100;
10 HANDLE g_hEvent;
11 
12 int main()
13 {
14     HANDLE hThread1;
15     HANDLE hThread2;
16     //创建事件对象
17     g_hEvent = CreateEvent( NULL,    //默认安全级别
18                             TRUE,    //人工重置
19                             FALSE,    //初始为无信号
20                             NULL );    //没有名字
21     //创建线程1
22     hThread1 = CreateThread(NULL,        //默认安全级别
23                             0,            //默认栈大小
24                             Thread1Proc,//线程函数 
25                             NULL,        //函数没有参数
26                             0,            //创建后直接运行
27                             NULL);        //线程标识，不需要
28 
29     //创建线程2
30     hThread2 = CreateThread(NULL,        //默认安全级别
31                             0,            //默认栈大小
32                             Thread2Proc,//线程函数 
33                             NULL,        //函数没有参数
34                             0,            //创建后直接运行
35                             NULL);        //线程标识，不需要
36 
37 
38     //主线程休眠4秒
39     Sleep(4000);
40     //关闭线程句柄
41     //当不再引用这个句柄时，立即将其关闭，减少其引用计数
42     CloseHandle(hThread1);
43     CloseHandle(hThread2);
44     //关闭事件对象句柄
45     CloseHandle(g_hEvent);
46     return 0;
47 }
48 
49 //线程1入口函数
50 DWORD WINAPI Thread1Proc(  LPVOID lpParameter)
51 {
52     while(TRUE)
53     {
54         WaitForSingleObject(g_hEvent,INFINITE);
55         if(tickets > 0)
56         {
57             Sleep(1);
58             printf("thread1 sell ticket : %d\n",tickets--);
59         }
60         else
61             break;
62     }
63 
64     return 0;
65 }
66 
67 //线程2入口函数
68 DWORD WINAPI Thread2Proc(  LPVOID lpParameter)
69 {
70     while(TRUE)
71     {
72         WaitForSingleObject(g_hEvent,INFINITE);
73         if(tickets > 0)
74         {
75             Sleep(1);
76             printf("thread2 sell ticket : %d\n",tickets--);
77         }
78         else
79             break;
80     }
81 
82     return 0;
83 }

程序运行后并没有出现两个线程买票的情况，而是等待了4秒之后直接退出了，这是什么原因呢？问题出在了我们创建的事件对象一开始就是无信号状态的，因此2个线程线程运行到WaitForSingleObject时就会一直等待，直到自己的时间片结束。所以什么也不会输出。
如果想让线程能够执行，可以在创建线程时将第3个参数设为TRUE，或者在创建完成后调用

1     SetEvent(g_hEvent);

程序的确可以实现买票了，但是有些时候，会打印出某个线程卖出第0张票的情况，这是因为当人工重置的事件对象得到通知时，等待该对象的所有线程均可变为可调度线程，两个线程同时运行，线程的同步失败了。

 

也许有人会想到，在线程得到CPU之后，能否使用ResetEvent是得线程将事件对象设为无信号状态，然后当所保护的代码运行完成后，再将事件对象设为有信号状态？我们可以试试：

 1 //线程1入口函数
 2 DWORD WINAPI Thread1Proc(  LPVOID lpParameter)
 3 {
 4     while(TRUE)
 5     {
 6         WaitForSingleObject(g_hEvent,INFINITE);
 7         ResetEvent(g_hEvent);
 8         if(tickets > 0)
 9         {
10             Sleep(10);
11             printf("thread1 sell ticket : %d\n",tickets--);
12             SetEvent(g_hEvent);
13         }
14         else
15         {
16             SetEvent(g_hEvent);
17             break;
18         }
19     }
20 
21     return 0;
22 }

线程2的类似，这里就省略了。运行程序，发现依然会出现卖出第0张票的情况。这是为什么呢？我们仔细思考一下：单核CPU下，可能线程1执行完WaitForSingleObject，还没来得及执行ResetEvent时，就切换到线程2了，此时，由于线程1并没有执行ResetEvent，所以线程2也可以得到事件对象了。而在多CPU平台下，假如两个线程同时执行，则有可能都执行到本应被保护的代码区域。
所以，为了实现线程间的同步，不应该使用人工重置的事件对象，而应该使用自动重置的事件对象：

1     hThread2 = CreateThread(NULL,0,Thread2Proc,NULL0,NULL);

并将原来写的ResetEvent和SetEvent全都注释起来。我们发现程序只打印了一次买票过程。我们分析一下原因：
当一个自动重置的事件得到通知后，等待该该事件的线程中只有一个变为可调度线程。在这里，线程1变为可调度线程后，操作系统将事件设为了无信号状态，当线程1休眠时，所以线程2只能等待，时间片结束以后，又轮到线程1运行，输出thread1 sell ticket :100。然后循环，又去WaitForSingleObject，而此时事件对象处于无信号状态，所以线程不能继续往下执行，只能一直等待，等到自己时间片结束，直到主线程睡醒了，结束整个程序。
正确的使用方法是：当访问完对保护的代码段后，立即调用SetEvent将其设为有信号状态。允许其他等待该对象的线程变为可调度状态：

 

 1 DWORD WINAPI Thread1Proc(  LPVOID lpParameter)
 2 {
 3     while(TRUE)
 4     {
 5         WaitForSingleObject(g_hEvent,INFINITE);
 6         if(tickets > 0)
 7         {
 8             Sleep(10);
 9             printf("thread1 sell ticket : %d\n",tickets--);
10             SetEvent(g_hEvent);
11         }
12         else
13         {
14             SetEvent(g_hEvent);
15             break;
16         }
17     }
18 
19     return 0;
20 }

总结一下：事件对象要区分人工重置事件还是自动重置事件。如果是人工重置的事件对象得到通知，则等待该事件对象的所有线程均变为可调度线程；当一个自动重置的事件对象得到通知时，只有一个等待该事件对象的线程变为可调度线程，且操作系统会将该事件对象设为无信号状态。因此，当执行完受保护的代码后，需要调用SetEvent将事件对象设为有信号状态。

 

下面介绍另一种线程同步的方法：关键代码段。
关键代码段又称为临界区，工作在用户方式下。它是一小段代码，但是在代码执行之前，必须独占某些资源的访问权限。
我们先介绍与之先关的API函数：
使用InitializeCriticalSection初始化关键代码段
使用EnterCriticalSection进入关键代码段：
使用LeaveCriticalSection离开关键代码段：
使用DeleteCriticalSection删除关键代码段，释放资源
我们看一个例子：

 1 #include <Windows.h>
 2 #include <stdio.h>
 3 
 4 //线程函数声明
 5 DWORD WINAPI Thread1Proc(  LPVOID lpParameter);
 6 DWORD WINAPI Thread2Proc(  LPVOID lpParameter);
 7 
 8 //全局变量
 9 int tickets = 100;
10 CRITICAL_SECTION g_cs;
11 
12 int main()
13 {
14     HANDLE hThread1;
15     HANDLE hThread2;
16     //初始化关键代码段
17     InitializeCriticalSection(&g_cs);
18     //创建线程1
19     hThread1 = CreateThread(NULL,        //默认安全级别
20                             0,            //默认栈大小
21                             Thread1Proc,//线程函数 
22                             NULL,        //函数没有参数
23                             0,            //创建后直接运行
24                             NULL);        //线程标识，不需要
25 
26     //创建线程2
27     hThread2 = CreateThread(NULL,        //默认安全级别
28                             0,            //默认栈大小
29                             Thread2Proc,//线程函数 
30                             NULL,        //函数没有参数
31                             0,            //创建后直接运行
32                             NULL);        //线程标识，不需要
33 
34 
35     //主线程休眠4秒
36     Sleep(4000);
37     //关闭线程句柄
38     CloseHandle(hThread1);
39     CloseHandle(hThread2);
40     //关闭事件对象句柄
41     DeleteCriticalSection(&g_cs);
42     return 0;
43 }
44 
45 //线程1入口函数
46 DWORD WINAPI Thread1Proc(  LPVOID lpParameter)
47 {
48     while(TRUE)
49     {
50         //进入关键代码段前调用该函数判断否能得到临界区的使用权
51         EnterCriticalSection(&g_cs);
52         Sleep(1);
53         if(tickets > 0)
54         {
55             Sleep(1);
56             printf("thread1 sell ticket : %d\n",tickets--);
57             //访问结束后释放临界区对象的使用权
58             LeaveCriticalSection(&g_cs);
59             Sleep(1);
60         }
61         else
62         {
63             LeaveCriticalSection(&g_cs);
64             break;
65         }
66     }
67 
68     return 0;
69 }
70 
71 //线程2入口函数
72 DWORD WINAPI Thread2Proc(  LPVOID lpParameter)
73 {
74     while(TRUE)
75     {
76         //进入关键代码段前调用该函数判断否能得到临界区的使用权
77         EnterCriticalSection(&g_cs);
78         Sleep(1);
79         if(tickets > 0)
80         {
81             Sleep(1);
82             printf("thread2 sell ticket : %d\n",tickets--);
83             //访问结束后释放临界区对象的使用权
84             LeaveCriticalSection(&g_cs);
85             Sleep(1);
86         }
87         else
88         {
89             LeaveCriticalSection(&g_cs);
90             break;
91         }
92     }
93 
94     return 0;
95 }

在这个例子中，通过在放弃临界区资源后，立即睡眠引起另一个线程被调用，导致两个线程交替售票。
下面看一个多线程程序中常犯的一个错误-线程死锁。死锁产生的原因，举个例子：线程1拥有临界区资源A，正在等待临界区资源B；而线程2拥有临界区资源B，正在等待临界区资源A。它俩各不相让，结果谁也执行不了。我们看看程序：

  1 #include <Windows.h>
  2 #include <stdio.h>
  3 
  4 //线程函数声明
  5 DWORD WINAPI Thread1Proc(  LPVOID lpParameter);
  6 DWORD WINAPI Thread2Proc(  LPVOID lpParameter);
  7 
  8 //全局变量
  9 int tickets = 100;
 10 CRITICAL_SECTION g_csA;
 11 CRITICAL_SECTION g_csB;
 12 int main()
 13 {
 14     HANDLE hThread1;
 15     HANDLE hThread2;
 16     //初始化关键代码段
 17     InitializeCriticalSection(&g_csA);
 18     InitializeCriticalSection(&g_csB);
 19     //创建线程1
 20     hThread1 = CreateThread(NULL,        //默认安全级别
 21                             0,            //默认栈大小
 22                             Thread1Proc,//线程函数 
 23                             NULL,        //函数没有参数
 24                             0,            //创建后直接运行
 25                             NULL);        //线程标识，不需要
 26 
 27     //创建线程2
 28     hThread2 = CreateThread(NULL,        //默认安全级别
 29                             0,            //默认栈大小
 30                             Thread2Proc,//线程函数 
 31                             NULL,        //函数没有参数
 32                             0,            //创建后直接运行
 33                             NULL);        //线程标识，不需要
 34     //关闭线程句柄
 35     //当不再引用这个句柄时，立即将其关闭，减少其引用计数
 36     CloseHandle(hThread1);
 37     CloseHandle(hThread2);
 38 
 39     //主线程休眠4秒
 40     Sleep(4000);
 41 
 42     //关闭事件对象句柄
 43     DeleteCriticalSection(&g_csA);
 44     DeleteCriticalSection(&g_csB);
 45     return 0;
 46 }
 47 
 48 //线程1入口函数
 49 DWORD WINAPI Thread1Proc(  LPVOID lpParameter)
 50 {
 51     while(TRUE)
 52     {
 53         EnterCriticalSection(&g_csA);
 54         Sleep(1);
 55         EnterCriticalSection(&g_csB);
 56         if(tickets > 0)
 57         {
 58             Sleep(1);
 59             printf("thread1 sell ticket : %d\n",tickets--);
 60             LeaveCriticalSection(&g_csB);
 61             LeaveCriticalSection(&g_csA);
 62             Sleep(1);
 63         }
 64         else
 65         {
 66             LeaveCriticalSection(&g_csB);
 67             LeaveCriticalSection(&g_csA);
 68             break;
 69         }
 70     }
 71 
 72     return 0;
 73 }
 74 
 75 //线程2入口函数
 76 DWORD WINAPI Thread2Proc(  LPVOID lpParameter)
 77 {
 78     while(TRUE)
 79     {
 80         EnterCriticalSection(&g_csB);
 81         Sleep(1);
 82         EnterCriticalSection(&g_csA);
 83         if(tickets > 0)
 84         {
 85             Sleep(1);
 86             printf("thread2 sell ticket : %d\n",tickets--);
 87             LeaveCriticalSection(&g_csA);
 88             LeaveCriticalSection(&g_csB);
 89             Sleep(1);
 90         }
 91         else
 92         {
 93             LeaveCriticalSection(&g_csA);
 94             LeaveCriticalSection(&g_csB);
 95             break;
 96         }
 97     }
 98 
 99     return 0;
100 }

在程序中，创建了两个临界区对象g_csA和g_csB。线程1中先尝试获取g_csA，获取成功后休眠，线程2尝试获取g_csB，成功后休眠，切换回线程1，然后线程1试图获取g_csB，因为g_csB已经被线程2获取，所以它线程1的获取不会成功，一直等待，直到自己的时间片结束后，转到线程2，线程2获取g_csB后，试图获取g_csA，当然也不会成功，转回线程1……这样交替等待，直到主线程睡醒，执行完毕，程序结束。