2. 程式人生 > >Windows執行緒同步的方法

Windows執行緒同步的方法

阿新 • • 發佈：2019-02-02

Summary：

對於多執行緒程式設計，一個很重要的問題就是解決由資料共享引起的資料競爭的問題，通過一定的執行緒同步的方法能避免資料競爭。在Win32多執行緒中，同步方法包括使用者態同步方式：InterLock、CriticalSection、SRWLock和核心態同步方式：Event、Semaphore、Mutex等。

本文主要目的是收集這些同步的方法和涉及到API的含義和使用，可能不會涉及到更深入的比如何時使用何種方式更好以及為什麼，更深入的問題，單獨在以後積累並記錄。

一、資料競爭的例子

在分析同步的方法之前，先給出要解決的資料競爭的例子：

[cpp] view plaincopy
print?
  1. #include "stdafx.h"
  2. #include 
  3. #include 
  4. #include 
  5. long g = 0;  
  6. #define THREAD_COUNT        10          // 執行緒數
  7. #define ACCESS_TIMES        10000000        // 訪問共享變數的次數，增大其值，增加資料競爭發生的可能性
  8. void __cdecl ThreadProc(void *para)  
  9. {  
  10.     printf("sub thread started\n");  
  11. for (int i = 0;i < ACCESS_TIMES;i++)  
  12.         g = g + 1;  
  13.     printf("sub thread finished\n");  
  14.     _endthread();   // 可以省略，隱含會呼叫。
  15. }  
  16. int main(int argc, char* argv[])  
  17. {  
  18. HANDLE hThread[THREAD_COUNT];  
  19. for(int i =0;i < THREAD_COUNT;i++)  
  20.         hThread[i] = (HANDLE)_beginthread(ThreadProc,0,NULL);  
  21. for(int i = 0;i < THREAD_COUNT;i++)  
  22.         WaitForSingleObject(hThread[i],INFINITE);  
  23. // 檢查結果
  24. if (g == ACCESS_TIMES*THREAD_COUNT)  
  25.         printf("Correct Result!\n");  
  26. else
  27.         printf("Error Result!\n");  
  28. }   
#include "stdafx.h" #include #include #include long g = 0; #define THREAD_COUNT 10 // 執行緒數 #define ACCESS_TIMES 10000000 // 訪問共享變數的次數，增大其值，增加資料競爭發生的可能性 void __cdecl ThreadProc(void *para) { printf("sub thread started\n"); for (int i = 0;i < ACCESS_TIMES;i++) g = g + 1; printf("sub thread finished\n"); _endthread(); // 可以省略，隱含會呼叫。 } int main(int argc, char* argv[]) { HANDLE hThread[THREAD_COUNT]; for(int i =0;i < THREAD_COUNT;i++) hThread[i] = (HANDLE)_beginthread(ThreadProc,0,NULL); for(int i = 0;i < THREAD_COUNT;i++) WaitForSingleObject(hThread[i],INFINITE); // 檢查結果 if (g == ACCESS_TIMES*THREAD_COUNT) printf("Correct Result!\n"); else printf("Error Result!\n"); }

如果程式輸出Error Result，說明發生了資料競爭。

二、使用者態同步

需要注意的是，由於使用者態到核心態的轉換需要一定的開銷，所以如果能在使用者態進行同步控制，儘量選擇使用者態的方式。

（1）InterLocked原子操作

InterLocked是一系列的方法，提供了原子操作的實現。原子操作比較容易理解，直接呼叫對應的API就能進行簡單的同步了，但是這種方式，顯然只能適用於簡單的預定義的一些操作方法，比如自增、自減、加法等，具體有哪些方法，可以參考MSDN（http://msdn.microsoft.com/zh-cn/site/ms684122）

對於上面的資料競爭的例子，顯然可以使用自增的原子操作來解決了，對於自增操作，MS提供了InterlockedIncrement()和InterlockedIncrement64()來完成原子操作，分別操作32位和64位的整數(long,long long)，引數為要進行自增的變數的地址。只需要將上述程式碼中，“g=g+1"修改為：

[cpp] view plaincopyprint?
  1. InterlockedIncrement(&g); // g = g + 1; 
InterlockedIncrement(&g); // g = g + 1;

即可解決資料競爭問題。

（2）Critical Section臨界區

百度百科：不論是硬體臨界資源，還是軟體臨界資源，多個程序必須互斥地對它進行訪問。每個程序中訪問臨界資源的那段程式碼稱為臨界區（Critical Section）（臨界資源是一次僅允許一個程序使用的共享資源）。每次只准許一個程序進入臨界區，進入後不允許其他程序進入。不論是硬體臨界資源，還是軟體臨界資源，多個程序必須互斥地對它進行訪問。

與臨界區相關的函式有：

EnterCriticalSection LeaveCriticalSectionInitializeCriticalSectionDeleteCriticalSectionTryEnterCriticalSection

EnterCriticalSection和LeaveCriticalSection是一對操作，表示進入和離開臨界區，同步控制一段程式碼的訪問，即在這兩個函式之間呼叫的程式碼，每次只允許一個執行緒執行。

InitializeCriticalSection和DeleteCriticalSection也是一對操作，分別是初始化和刪除臨界區（變數），在使用臨界區的時候，需要定義一個臨界區變數，代表一個臨界區資源。所以，一個程式可以使用多個臨界區變數來進行不同的程式碼段的保護。在呼叫EnterCriticalSection的時候，如果臨界區被其它執行緒佔有，那麼當前執行緒會等待資源，知道其它執行緒退出臨界區。TryEnterCriticalSection函式就是用來嘗試進入臨界區，如果無法進入臨界區(臨界區被佔有)，那麼返回FALSE，不會阻塞執行緒。

下面是使用臨界區解決上述問題的程式碼：

[cpp] view plaincopyprint?
  1. #include "stdafx.h"
  2. #include 
  3. #include 
  4. #include 
  5. long g = 0;  
  6. CRITICAL_SECTION g_cs;      // 定義臨界區
  7. #define THREAD_COUNT        10          // 執行緒數
  8. #define ACCESS_TIMES        10000000        // 訪問共享變數的次數，增大其值，增加資料競爭發生的可能性
  9. void __cdecl ThreadProc(void *para)  
  10. {  
  11.     printf("sub thread started\n");  
  12. for (int i = 0;i < ACCESS_TIMES;i++)  
  13.         {  
  14.             EnterCriticalSection(&g_cs);    // 進入臨界區
  15.             g = g + 1;  
  16.             LeaveCriticalSection(&g_cs);    // 退出臨界區
  17.         }  
  18.     printf("sub thread finished\n");  
  19.     _endthread();   // 可以省略，隱含會呼叫。
  20. }  
  21. int main(int argc, char* argv[])  
  22. {  
  23.     InitializeCriticalSection(&g_cs);   // 初始化臨界區
  24. HANDLE hThread[THREAD_COUNT];  
  25. for(int i =0;i < THREAD_COUNT;i++)  
  26.         hThread[i] = (HANDLE)_beginthread(ThreadProc,0,NULL);  
  27. for(int i = 0;i < THREAD_COUNT;i++)  
  28.         WaitForSingleObject(hThread[i],INFINITE);  
  29.     DeleteCriticalSection(&g_cs);   // 刪除臨界區
  30. // 檢查結果
  31. if (g == ACCESS_TIMES*THREAD_COUNT)  
  32.         printf("Correct Result!\n");  
  33. else
  34.         printf("Error Result!\n");  
  35. }   
#include "stdafx.h" #include #include #include long g = 0; CRITICAL_SECTION g_cs; // 定義臨界區 #define THREAD_COUNT 10 // 執行緒數 #define ACCESS_TIMES 10000000 // 訪問共享變數的次數，增大其值，增加資料競爭發生的可能性 void __cdecl ThreadProc(void *para) { printf("sub thread started\n"); for (int i = 0;i < ACCESS_TIMES;i++) { EnterCriticalSection(&g_cs); // 進入臨界區 g = g + 1; LeaveCriticalSection(&g_cs); // 退出臨界區 } printf("sub thread finished\n"); _endthread(); // 可以省略，隱含會呼叫。 } int main(int argc, char* argv[]) { InitializeCriticalSection(&g_cs); // 初始化臨界區 HANDLE hThread[THREAD_COUNT]; for(int i =0;i < THREAD_COUNT;i++) hThread[i] = (HANDLE)_beginthread(ThreadProc,0,NULL); for(int i = 0;i < THREAD_COUNT;i++) WaitForSingleObject(hThread[i],INFINITE); DeleteCriticalSection(&g_cs); // 刪除臨界區 // 檢查結果 if (g == ACCESS_TIMES*THREAD_COUNT) printf("Correct Result!\n"); else printf("Error Result!\n"); }
可見，臨界區能保護一個程式碼塊，使用起來比原子操作更靈活。

（3）SRWLOCK讀寫鎖

讀寫鎖實際是一種特殊的自旋鎖，它把對共享資源的訪問者劃分成讀者和寫者，讀者只對共享資源進行讀訪問，寫者則需要對共享資源進行寫操作。這種鎖相對於自旋鎖而言，能提高併發性，因為在多處理器系統中，它允許同時有多個讀者來訪問共享資源，最大可能的讀者數為實際的邏輯CPU數。寫者是排他性的，一個讀寫鎖同時只能有一個寫者或多個讀者（與CPU數相關），但不能同時既有讀者又有寫者。

說明：在win32中，自旋鎖是核心定義，且只能在核心狀態下使用的一種鎖機制。所以一般的程式不會用到，需要一定的要求。而SRWLOCK讀寫鎖是使用者態下的讀寫鎖。

從使用上，SRWLOCK和臨界區的使用非常類似，讀寫鎖和臨界區的主要區別是，讀寫鎖對共享資源的訪問區分了讀者和寫者分離的功能。所以，SRWLOCK比臨界區多了一些方法。

AcquireSRWLockShared
AcquireSRWLockExclusive
ReleaseSRWLockShared
ReleaseSRWLockExclusive
InitializeSRWLock
TryAcquireSRWLockExclusive
TryAcquireSRWLockShared
SleepConditionVariableSRW

其中，AcquireSRWLockShared和AcquireSRWLockExclusive表示獲取讀鎖和獲取寫鎖（共享鎖和排他鎖）。ReleaseSRWLockShared和ReleaseSRWLockExclusive表示釋放讀鎖和寫鎖。和臨界區一樣，InitializeSRWLock是初始化。但是，SRWLock沒有提供刪除讀寫鎖的方法，不需要刪除。TryAcquireSRWLockExclusive和TryAcquireSRWLockShared也是用於非阻塞的方式獲取讀鎖和寫鎖，失敗返回FALSE。SleepConditionVariableSRW在下面再介紹。需要說明的是：TryAcquireSRWLockExclusive和TryAcquireSRWLockShared是Win7才開始提供支援的，詳細資訊參考MSDN。

下面是使用讀寫鎖解決上面的資料競爭的問題：（說明：這裡只需要獲取寫鎖，更多的程式可能會需要同時使用讀鎖和寫鎖）

[cpp] view plaincopyprint?
  1. #include "stdafx.h"
  2. #include 
  3. #include 
  4. #include 
  5. long g = 0;  
  6. SRWLOCK g_srw;      // 定義讀寫鎖
  7. #define THREAD_COUNT        10          // 執行緒數
  8. #define ACCESS_TIMES        10000000        // 訪問共享變數的次數，增大其值，增加資料競爭發生的可能性
  9. void __cdecl ThreadProc(void *para)  
  10. {  
  11.     printf("sub thread started\n");  
  12. for (int i = 0;i < ACCESS_TIMES;i++)  
  13.         {  
  14.             AcquireSRWLockExclusive(&g_srw);    // 獲取寫鎖
  15.             g = g + 1;  
  16.             ReleaseSRWLockExclusive(&g_srw);    // 釋放寫鎖
  17.         }  
  18.     printf("sub thread finished\n");  
  19.     _endthread();   // 可以省略，隱含會呼叫。
  20. }  
  21. int main(int argc, char* argv[])  
  22. {  
  23.     InitializeSRWLock(&g_srw);  // 初始化讀寫鎖
  24. HANDLE hThread[THREAD_COUNT];  
  25. for(int i =0;i < THREAD_COUNT;i++)  
  26.         hThread[i] = (HANDLE)_beginthread(ThreadProc,0,NULL);  
  27. for(int i = 0;i < THREAD_COUNT;i++)  
  28.         WaitForSingleObject(hThread[i],INFINITE);  
  29. // 檢查結果
  30. if (g == ACCESS_TIMES*THREAD_COUNT)  
  31.         printf("Correct Result!\n");  
  32. else
  33.         printf("Error Result!\n");  
  34. }   
#include "stdafx.h" #include #include #include long g = 0; SRWLOCK g_srw; // 定義讀寫鎖 #define THREAD_COUNT 10 // 執行緒數 #define ACCESS_TIMES 10000000 // 訪問共享變數的次數，增大其值，增加資料競爭發生的可能性 void __cdecl ThreadProc(void *para) { printf("sub thread started\n"); for (int i = 0;i < ACCESS_TIMES;i++) { AcquireSRWLockExclusive(&g_srw); // 獲取寫鎖 g = g + 1; ReleaseSRWLockExclusive(&g_srw); // 釋放寫鎖 } printf("sub thread finished\n"); _endthread(); // 可以省略，隱含會呼叫。 } int main(int argc, char* argv[]) { InitializeSRWLock(&g_srw); // 初始化讀寫鎖 HANDLE hThread[THREAD_COUNT]; for(int i =0;i < THREAD_COUNT;i++) hThread[i] = (HANDLE)_beginthread(ThreadProc,0,NULL); for(int i = 0;i < THREAD_COUNT;i++) WaitForSingleObject(hThread[i],INFINITE); // 檢查結果 if (g == ACCESS_TIMES*THREAD_COUNT) printf("Correct Result!\n"); else printf("Error Result!\n"); }

讀寫鎖的適用情況：讀寫鎖適合於對資料結構的讀次數比寫次數多得多的情況。更多相關問題，參考關於讀寫鎖的特性等的分析介紹。

（4）Condition Variable條件變數

條件變數一開始是在Linux中有，Window平臺是從Vista才開始支援條件變數（所以XP不支援）。

條件變數是利用執行緒間共享的全域性變數進行同步的一種機制，主要包括兩個動作：一個執行緒等待"條件變數的條件成立"而掛起；另一個執行緒使"條件成立"（給出條件成立訊號）。為了防止競爭，條件變數的使用總是和一個互斥鎖結合在一起。其實，在windows下，條件變數的使用總是和讀寫鎖或臨界區結合使用（因為Linux下沒有臨界區，所以這裡只說了互斥鎖）。

和條件變數相關的函式有：

Condition variable function
InitializeConditionVariable
SleepConditionVariableCS
SleepConditionVariableSRW
WakeAllConditionVariable
WakeConditionVariable

具體使用說明可以參考MSDN，由於條件變數和這裡的資料競爭的例子很難結合起來，這裡就不舉例了，而且它單獨是無法完成同步的，所以這裡也沒必要單獨作為一種同步的方法來說明，關於條件變數的使用場合和使用方法，參考其它內容。

三、核心態同步

上面介紹的都是使用者態的同步方法，win32多執行緒還提供了一些核心態同步的方式。從效能上來說，核心態同步方式比使用者態更低，原因是使用者態到核心態的轉換是有開銷的。但是核心態的優點在於是可以跨程序同步的，所以不僅僅是執行緒同步方式，也是一種程序同步方式。

（1）核心物件和狀態

在瞭解核心態同步之前，首先需要了解很重要的兩個函式：WaitForSingleObject和WaitForMultipleObjects。

1. 核心物件

核心物件只是核心分配的一個記憶體塊，並且只能由該核心訪問。該記憶體塊是一種資料結構，它的成員負責維護該物件的各種資訊。有些資料成員（如安全性描述符、使用計數等）在所有物件型別中是相同的，但大多數資料成員屬於特定的物件型別。例如，程序物件有一個程序I D 、一個基本優先順序和一個退出程式碼，而檔案物件則擁有一個位元組位移、一個共享模式和一個開啟模式。

參考：

總之，這裡要提到的核心態同步的物件，都是屬於核心物件，包括程序物件和執行緒物件也是屬於核心物件。另外要知道的是，核心物件使用相應的建立函式建立，返回都是控制代碼，即HANDLE物件。

2. 核心同步物件

在Windows NT核心物件中，提供了五種核心同步物件（Kernel Dispatcher Object），為：Event(事件)、Semaphore(訊號燈/訊號量)、Mutex(互斥)、Timer(定時器)、Thread(執行緒)。

3. 核心物件的狀態

在任何時刻，任何物件都處於兩種狀態中的一種：訊號態或非訊號態（參考上面的連結的說明，沒有找到官方證實這句話，但是至少對於核心同步物件，所有的物件應該都是有這兩個狀態的）。有時候，這兩個狀態稱為受信狀態（signaled state)和非受信狀態(nonsignaled state)或者通知狀態和未通知狀態。

到了這裡，我們就可以討論WaitForSingleObject了。WaitForSingleObject的引數是一個核心物件控制代碼，它的作用是：Waits until the specified object is in the signaled state or the time-out interval elapses。即等待指定的物件處於受信狀態或者出現超時，等待，表明如果執行WaitForSingleObject的時候，物件處於非受信狀態，那麼當前執行緒處於阻塞狀態。當然，WaitForMultipleObjects的作用就是等待多個狀態了。

說明，WaitForSingleObject對於某些核心物件是由副作用的，比如對於訊號量，等待成功會使得訊號量減1。

Change notification
Console input
Event
Memory resource notification
Mutex
Process
Semaphore
Thread
Waitable timer

其中加粗的幾個核心物件是多執行緒程式設計中會遇到的（三個核心態同步物件和一個執行緒物件）。理解了signaled state和nonsignaled state之後，下面的三種核心態同步方式就很容易理解了。

（2）Event事件

事件核心物件包括兩種：人工重置的事件和自動重置的事件。

當人工重置事件得到通知時，等待該事件的所有執行緒成為可排程執行緒；它沒有成功等待副作用。
當自動重置的事件得到通知時，等待該事件的執行緒中只有一個執行緒變為可排程執行緒。其成功等待的副作用是該物件自動重置為未通知狀態。

事件核心物件通過CreateEvent建立，初始可以是通知或未通知狀態。

人工事件一般用於一個執行緒通知另一個執行緒或者一個執行緒通知多個執行緒進行某一操作。自動事件適用於保護資源在同一時間只能有一個執行緒可以訪問，它能保證只有一個執行緒被啟用。

事件物件分為命名事件物件和未命名物件（named and unnamed event objects）。

和事件物件相關的函式有：CreateEvent/OpenEvent、ResetEvent、SetEvent、PulseEvent等。

其中，CreateEvent建立或開啟一個事件物件，其中，四個引數分別為安全屬性（核心物件都有安全屬性），是否為人工重置事件，初始狀態（TRUE表示signaled，FALSE表示nonsignled），事件物件的名字，如果為NULL，建立一個未命名事件物件。如果指定name的事件已經存在，則獲得EVENT_ALL_ACCESS的訪問許可權，第一個引數部分有效，後兩個引數忽略。OpenEvent用於開啟已存在的事件（所以一般用CreateEvent即可）。ResetEvent/SetEvent分別設定事件的狀態為nonsignaled和signaled。PulseEvent根據MSDN不可信，所以不推薦使用（相當於reset然後set的功能，但是並不可靠）。

總之，對於事件來說，常用的方法是CreateEvent，ResetEvent，SetEvent，然後利用WaitForSingleObject來等待事件（變成singled狀態）。

仍然針對上面的資料競爭的例子，使用事件解決的方法是：

[cpp] view plaincopyprint?
  1. #include "stdafx.h"
  2. #include 
  3. #include 
  4. #include 
  5. long g = 0;  
  6. HANDLE g_event; // 事件控制代碼
  7. #define THREAD_COUNT        10          // 執行緒數
  8. #define ACCESS_TIMES        100000      // 訪問共享變數的次數，增大其值，增加資料競爭發生的可能性
  9. void __cdecl ThreadProc(void *para)  
  10. {  
  11.     printf("sub thread started\n");  
  12. for (int i = 0;i < ACCESS_TIMES;i++)  
  13.     {  
  14.         WaitForSingleObject(g_event, INFINITE);     // 等待事件
  15.         ResetEvent(g_event);        // 重置事件，讓其他執行緒繼續等待（相當於獲取鎖）
  16.         g = g + 1;  
  17.         SetEvent(g_event);          // 設定事件，讓其他執行緒可以獲取事件（相當於釋放鎖）
  18.     }  
  19.     printf("sub thread finished\n");  
  20.     _endthread();   // 可以省略，隱含會呼叫。
  21. }  
  22. int main(int argc, char* argv[])  
  23. {  
  24.     g_event = CreateEvent(NULL, FALSE, FALSE, NULL);        // 建立事件核心物件
  25.     SetEvent(g_event);  
  26. HANDLE hThread[THREAD_COUNT];  
  27. for(int i = 0;i < THREAD_COUNT;i++)  
  28.         hThread[i] = (HANDLE)_beginthread(ThreadProc,0,NULL);  
  29. for(int i = 0;i < THREAD_COUNT;i++)  
  30.         WaitForSingleObject(hThread[i],INFINITE);  
  31. // 檢查結果
  32. if (g == ACCESS_TIMES*THREAD_COUNT)  
  33.         printf("Correct Result!\n");  
  34. else
  35.         printf("Error Result!\n");  
  36. }   
#include "stdafx.h" #include #include #include long g = 0; HANDLE g_event; // 事件控制代碼 #define THREAD_COUNT 10 // 執行緒數 #define ACCESS_TIMES 100000 // 訪問共享變數的次數，增大其值，增加資料競爭發生的可能性 void __cdecl ThreadProc(void *para) { printf("sub thread started\n"); for (int i = 0;i < ACCESS_TIMES;i++) { WaitForSingleObject(g_event, INFINITE); // 等待事件 ResetEvent(g_event); // 重置事件，讓其他執行緒繼續等待（相當於獲取鎖） g = g + 1; SetEvent(g_event); // 設定事件，讓其他執行緒可以獲取事件（相當於釋放鎖） } printf("sub thread finished\n"); _endthread(); // 可以省略，隱含會呼叫。 } int main(int argc, char* argv[]) { g_event = CreateEvent(NULL, FALSE, FALSE, NULL); // 建立事件核心物件 SetEvent(g_event); HANDLE hThread[THREAD_COUNT]; for(int i = 0;i < THREAD_COUNT;i++) hThread[i] = (HANDLE)_beginthread(ThreadProc,0,NULL); for(int i = 0;i < THREAD_COUNT;i++) WaitForSingleObject(hThread[i],INFINITE); // 檢查結果 if (g == ACCESS_TIMES*THREAD_COUNT) printf("Correct Result!\n"); else printf("Error Result!\n"); }

說明：實際執行就會發現，核心態事件物件同步的方法比使用者態的方法的效率低很多，如果這裡的ACCESS_TIMES如果太大，執行時間相比使用者態的方法多很多。當然，再次強調，這裡都是用這一個例子，只是為了分析各種方法實現同步的實現，實際應用，顯然是有所取捨的，不同的同步方法有不同的合適的使用情景。

（3）Semaphore訊號量

訊號量用來對資源進行計數。它包含兩個32位值，一個表示能夠使用的最大資源數量，一個表示當前可用的資源數量。
訊號量的使用規則為：如果當前資源數量大於0，發出訊號量訊號；如果當前資源數量是0，不發出訊號量訊號；不允許當前資源數量為負值
 當前資源數量不能大於最大訊號數量。

當呼叫等待函式時，它會檢查訊號量的當前資源數量。如果它的值大於0，那麼計數器減1，呼叫執行緒處於可排程狀態。如果當前資源是0，則呼叫函式的執行緒進入等待狀態。當另一個執行緒對訊號量的當前資源通過ReleaseSemaphore進行遞增時，系統會記住該等待執行緒，並將其變為可排程狀態。

對於訊號量，相關的函式有：CreateSemaphore/OpenSemaphore、ReleaseSemaphore。WaitForSingleObject對於訊號量，成功等待的副作用是使得訊號量減1。從某種角度理解，事件相當於最大計數為1的訊號量。

下面的例子是使用最大計數為1的訊號量來解決上面的資料競爭問題：

[cpp] view plaincopyprint?
  1. #include "stdafx.h"
  2. #include 
  3. #include 
  4. #include 
  5. long g = 0;  
  6. HANDLE g_semaphore;     // 訊號量物件控制代碼
  7. #define THREAD_COUNT        10          // 執行緒數
  8. #define ACCESS_TIMES        100000      // 訪問共享變數的次數，增大其值，增加資料競爭發生的可能性
  9. void __cdecl ThreadProc(void *para)  
  10. {  
  11.     printf("sub thread started\n");  
  12. for (int i = 0;i < ACCESS_TIMES;i++)  
  13.     {  
  14.         WaitForSingleObject(g_semaphore, INFINITE);     // 等待訊號量
  15. // 獲取訊號量後計數會減1
  16.         g = g + 1;  
  17.         ReleaseSemaphore(g_semaphore,1, NULL);                      // 訊號量加1
  18.     }  
  19.     printf("sub thread finished\n");  
  20.     _endthread();   // 可以省略，隱含會呼叫。
  21. }  
  22. int main(int argc, char* argv[])  
  23. {  
  24.     g_semaphore = CreateSemaphore(NULL, 0, 1, NULL);        // 建立訊號量，初始計數為0，最大計數為1
  25.     ReleaseSemaphore(g_semaphore,1, NULL);          // 將計數設定為1
  26. HANDLE hThread[THREAD_COUNT];  
  27. for(int i = 0;i < THREAD_COUNT;i++)  
  28.         hThread[i] = (HANDLE)_beginthread(ThreadProc,0,NULL);  
  29. for(int i = 0;i < THREAD_COUNT;i++)  
  30.         WaitForSingleObject(hThread[i],INFINITE);  
  31. // 檢查結果
  32. if (g == ACCESS_TIMES*THREAD_COUNT)  
  33.         printf("Correct Result!\n");  
  34. else
  35.         printf("Error Result!\n");  
  36. }   
#include "stdafx.h" #include #include #include long g = 0; HANDLE g_semaphore; // 訊號量物件控制代碼 #define THREAD_COUNT 10 // 執行緒數 #define ACCESS_TIMES 100000 // 訪問共享變數的次數，增大其值，增加資料競爭發生的可能性 void __cdecl ThreadProc(void *para) { printf("sub thread started\n"); for (int i = 0;i < ACCESS_TIMES;i++) { WaitForSingleObject(g_semaphore, INFINITE); // 等待訊號量 // 獲取訊號量後計數會減1 g = g + 1; ReleaseSemaphore(g_semaphore,1, NULL); // 訊號量加1 } printf("sub thread finished\n"); _endthread(); // 可以省略，隱含會呼叫。 } int main(int argc, char* argv[]) { g_semaphore = CreateSemaphore(NULL, 0, 1, NULL); // 建立訊號量，初始計數為0，最大計數為1 ReleaseSemaphore(g_semaphore,1, NULL); // 將計數設定為1 HANDLE hThread[THREAD_COUNT]; for(int i = 0;i < THREAD_COUNT;i++) hThread[i] = (HANDLE)_beginthread(ThreadProc,0,NULL); for(int i = 0;i < THREAD_COUNT;i++) WaitForSingleObject(hThread[i],INFINITE); // 檢查結果 if (g == ACCESS_TIMES*THREAD_COUNT) printf("Correct Result!\n"); else printf("Error Result!\n"); }


（4）Mutex互斥（互斥物件，互斥體）

互斥器保證執行緒擁有對單個資源的互斥訪問權。互斥物件類似於關鍵程式碼區（臨界區），但它是一個核心物件。互斥器不同於其他核心物件，它有一個“執行緒所有權”的概念。它如果被某個執行緒等待成功，就屬於該執行緒。

由於和臨界區和讀寫鎖很類似，使用也是很類似的。和Mute相關的函式主要有：CreateMutex/OpenMutex，ReleaseMutex。很顯然，Create是建立，Open是開啟已存在的命名互斥物件，ReleaseMutex是釋放互斥物件。幾乎和臨界區的函式一樣，當然，用WaitForSingleObject等待互斥體，類似於進入臨界區的操作了。

程式碼如下：

[cpp] view plaincopyprint?
  1. #include "stdafx.h"
  2. #include 
  3. #include 
  4. #include 
  5. long g = 0;  
  6. HANDLE g_mutex;     // 互斥物件控制代碼
  7. #define THREAD_COUNT        10          // 執行緒數
  8. #define ACCESS_TIMES        100000      // 訪問共享變數的次數，增大其值，增加資料競爭發生的可能性
  9. void __cdecl ThreadProc(void *para)  
  10. {  
  11.     printf("sub thread started\n");  
  12. for (int i = 0;i < ACCESS_TIMES;i++)  
  13.     {  
  14.         WaitForSingleObject(g_mutex, INFINITE);     // 等待互斥物件
  15.         g = g + 1;  
  16.         ReleaseMutex(g_mutex);                      // 釋放互斥物件
  17.     }  
  18.     printf("sub thread finished\n");  
  19.     _endthread();   // 可以省略，隱含會呼叫。
  20. }  
  21. int main(int argc, char* argv[])  
  22. {  
  23.     g_mutex = CreateMutex(NULL, FALSE, NULL);       // 建立互斥核心物件
  24. HANDLE hThread[THREAD_COUNT];  
  25. for(int i = 0;i < THREAD_COUNT;i++)  
  26.         hThread[i] = (HANDLE)_beginthread(ThreadProc,0,NULL);  
  27. for(int i = 0;i < THREAD_COUNT;i++)  
  28.         WaitForSingleObject(hThread[i],INFINITE);  
  29. // 檢查結果
  30. if (g == ACCESS_TIMES*THREAD_COUNT)  
  31.         printf("Correct Result!\n");  
  32. else
  33.         printf("Error Result!\n");  
  34. }   
#include "stdafx.h" #include #include #include long g = 0; HANDLE g_mutex; // 互斥物件控制代碼 #define THREAD_COUNT 10 // 執行緒數 #define ACCESS_TIMES 100000 // 訪問共享變數的次數，增大其值，增加資料競爭發生的可能性 void __cdecl ThreadProc(void *para) { printf("sub thread started\n"); for (int i = 0;i < ACCESS_TIMES;i++) { WaitForSingleObject(g_mutex, INFINITE); // 等待互斥物件 g = g + 1; ReleaseMutex(g_mutex); // 釋放互斥物件 } printf("sub thread finished\n"); _endthread(); // 可以省略，隱含會呼叫。 } int main(int argc, char* argv[]) { g_mutex = CreateMutex(NULL, FALSE, NULL); // 建立互斥核心物件 HANDLE hThread[THREAD_COUNT]; for(int i = 0;i < THREAD_COUNT;i++) hThread[i] = (HANDLE)_beginthread(ThreadProc,0,NULL); for(int i = 0;i < THREAD_COUNT;i++) WaitForSingleObject(hThread[i],INFINITE); // 檢查結果 if (g == ACCESS_TIMES*THREAD_COUNT) printf("Correct Result!\n"); else printf("Error Result!\n"); }


總結：這裡介紹了使用者態和核心態的同步物件和基本函式的使用。這裡只是為了演示其使用和理解其概念，針對實際應用，需要根據實際的case選擇合適的方法進行同步。

相關文章：

相關推薦

windows 執行緒同步的4種方法

1. 互斥訊號量  #include <windows.h> #include <iostream>usingnamespace std; DWORD WINAPI Fun1Proc(LPVOID param); DWORD WINAPI Fun

Windows執行緒同步的方法

Summary： 對於多執行緒程式設計，一個很重要的問題就是解決由資料共享引起的資料競爭的問題，通過一定的執行緒同步的方法能避免資料競爭。在Win32多執行緒中，同步方法包括使用者態同步方式：InterLock、CriticalSection、SRWLock和核心態同步方式：Event、Semaphore、

java執行緒同步方法

1.同步方法     synchronized修飾方法，物件內建鎖保護整個方法（物件鎖）     若方法static修飾，類鎖 2.同步程式碼塊     同步—高開銷—減少同步內容 3.wait和notify   &n

java執行緒---同步方法

關鍵字synchronized方法方法上修飾，那麼該方法就是同步方法。同步方法分為 ：非靜態同步方法和靜態同步方法。程式碼如下：非靜態同步方法package sx.test.thread;public class Demo4 {public static void main(

Windows執行緒同步之互斥鎖（Mutex）

執行緒同步的方式和機制臨界區、互斥區、事件、訊號量四種方式臨界區（Critical Section）、互斥量（Mutex）、訊號量（Semaphore）、事件（Event）的區別1、臨界區：通過對多執行緒的序列化來訪問公共資源或一段程式碼，速度快，適合控制資料訪問。在任意時刻

Java基礎學習之執行緒同步方法總結

        引入執行緒同步的原因：當有多個執行緒要同時訪問一個變數或物件時，如果這些執行緒中既有讀又有寫操作時，就會導致變數值或物件的狀態出現混亂，從而導致程式異常，使用者也得不到想要的結果。比如，如果一個銀行賬戶同時被兩個執行緒操作，一個取100塊，一個

多執行緒同步方法彙總

多執行緒同步方法彙總 為什麼需要同步？ synchronized關鍵字 使用同步鎖 執行緒通訊 Volatile關鍵字 參考文獻 為什麼需要同步？ 多個執行緒同時訪問一個物件時，可能會同時出現讀寫這個物件，那麼這個物件

執行緒同步方法：

 互斥鎖        lock_the_mutex(...); 　　臨界區 　　unlock_the_mutex(...);   互斥鎖通常用於保護由多個執行緒或多個程序共享的共享資料(S

windows執行緒同步的總結

http://blog.csdn.net/peter_teng/article/details/11230525 一 執行緒 1）如果你正在編寫C/C++程式碼，決不應該呼叫CreateThread。相反，應該使用VisualC++執行期庫函式_beginthread

JAVA#執行緒同步方法'札記

public static void main(String[] args) { Shixian s1=new Shixian(); Thread t1=new Thread(s1); t1.setName("宋小艾"); t1.st

NET多執行緒同步方法詳解(五)：訊號量(Semaphore)

   訊號量就像一個夜總會：它有確切的容量，並被保鏢控制。一旦滿員，就沒有人能再進入，其他人必須在外面排隊。那麼在裡面離開一個人後，隊頭的人就可以進入。訊號量的建構函式需要提供至少兩個引數-現有的人數和最大的人數。 訊號

多執行緒同步方法資料庫悲觀鎖（for update)

 悲觀鎖，正如其名，具有強烈的獨佔和排他特性。上來就鎖住，把事情考慮的比較悲觀，它是採用資料庫機制實現的，資料庫被鎖之後其它使用者將無法檢視，直到提交或者回滾，鎖釋放之後才可檢視。所以悲觀鎖具有其霸道

VC常用執行緒同步方法

臨界區：一種保證在某一時刻只有一個執行緒能訪問資料的簡便辦法。它只可以在同一程序內部使用。主要API函式有，產生臨界區：InitializeCriticalSection，刪除臨界區：DeleteCri

windows執行緒同步機制摘要

執行緒之間的同步使用一些核心物件：如thread,  process, evnet, mutex, semaphore. 線上程之間使用等待函式如WaitForSingleObjects,  WaitForMultipleObjects. 等待函式使用核心物件的handle作

一種Windows下執行緒同步的實現方法

一種Windows下執行緒同步的實現方法 Windows下的多執行緒與執行緒同步概述 多工是一個作業系統可以同時執行多個程式的能力。基本上，作業系統使用一個硬體時鐘為同時執行的每個程序分配“時間片”。如果時間片足夠小，並且機器也沒有由於太多的程式而超負荷，那麼在使用者看來，所

【Windows】執行緒漫談——.NET執行緒同步之Interlocked和ReadWrite鎖

摘要: 本系列意在記錄Windwos執行緒的相關知識點，包括執行緒基礎、執行緒排程、執行緒同步、TLS、執行緒池等。 這篇來說說靜態的Interlocked類和ReadWrite鎖 .NET中的Interlock

Windows程式設計之執行緒同步

Windows程式設計中執行緒同步的主要機制：互斥、事件、訊號量、可等待定時器，不說了，直接上程式碼： // ThreadSync.cpp : 定義控制檯應用程式的入口點。 // #include "stdafx.h" #include <windows.h>

【Windows原理】執行緒同步-訊號量

#include "stdafx.h" #include <windows.h> int g_num = 0; HANDLE g_hSemaphore = nullptr; DWORD WINAPI ThreadProc(LPVOID lpParam) { for

【Windows原理】執行緒同步-事件物件2

#include "stdafx.h" #include <windows.h> HANDLE g_hEventA = nullptr; // 三個只讀執行緒 DWORD WINAPI ThreadProcA(LPVOID lpParam) { WaitForSin

【Windows原理】執行緒同步-事件物件

#include "stdafx.h" #include <windows.h> HANDLE g_hEventA = nullptr; HANDLE g_hEventB = nullptr; DWORD WINAPI ThreadProcA(LPVOID lpParam) {