碼上快樂

相關內容    簡體    繁體

(轉)Windows下C++多線程同步與互斥簡單運用

本文轉載自   查看原文   2019-05-10 13:36   572    C++隨記/ 轉載文章/ C/C++語法/ MFC/ 計算機常識

1.  互斥量，Mutex

 

[cpp]  view plain copy
 
  1. #include <Windows.h>  
  2. #include <iostream>  
  3. using namespace std;  
  4. DWORD WINAPI Thread1(LPVOID lpParmeter);  
  5. DWORD WINAPI Thread2(LPVOID lpParmeter);  
  6. static HANDLE g_hMutex = INVALID_HANDLE_VALUE;  
  7. static int g_iCnt = 100;  
  8. int main()  
  9. {  
  10.     HANDLE hThread1 = INVALID_HANDLE_VALUE;  
  11.     HANDLE hThread2 = INVALID_HANDLE_VALUE;  
  12.     g_hMutex = CreateMutex(NULL, FALSE, "Mutex");  
  13.     // 第二個參數：創建者是否擁有所有權，FALSE為沒有所有權，  
  14.     // 遇到第一個WaitForSingleObject的時候就把所有權給它，  
  15.     // 所以Thread1里面的WaitForSingleObject(g_hMutex, INFINITE)能夠繼續執行  
  16.     if (!g_hMutex)  
  17.     {  
  18.         cout << "Failed to CreateMutex !" << endl;  
  19.         return 0;  
  20.     }  
  21.     hThread1 = CreateThread(NULL, 0, Thread1, NULL, 0, NULL);  
  22.     hThread2 = CreateThread(NULL, 0, Thread2, NULL, 0, NULL);  
  23.     Sleep(4000);        // 讓2個線程有足夠的時間執行完操作。  
  24.     CloseHandle(hThread1);  
  25.     CloseHandle(hThread2);  
  26.     system("PAUSE");  
  27.     return 0;  
  28. }  
  29. DWORD WINAPI Thread1(LPVOID lpParmeter)  
  30. {  
  31.     while (true)  
  32.     {  
  33.         // 請求事件對象  
  34.         WaitForSingleObject(g_hMutex, INFINITE);    // INFINITE: 長時間等待，差不多50天左右吧！  
  35.         if (g_iCnt > 0)  
  36.         {  
  37.             Sleep(20);  
  38.             cout << "Thread1:" << g_iCnt-- << endl;  
  39.             ReleaseMutex(g_hMutex);                 // 釋放資源  
  40.         }  
  41.         else  
  42.         {  
  43.             ReleaseMutex(g_hMutex);  
  44.             break;  
  45.         }  
  46.     }  
  47.     return 0;  
  48. }  
  49. DWORD WINAPI Thread2(LPVOID lpParameter)//thread data  
  50. {  
  51.     while (true)  
  52.     {  
  53.         // 請求事件對象  
  54.         WaitForSingleObject(g_hMutex,INFINITE);  
  55.         if (g_iCnt > 0)  
  56.         {  
  57.             Sleep(20);  
  58.             cout << "thread2:" << g_iCnt-- << endl;  
  59.             ReleaseMutex(g_hMutex);  
  60.         }  
  61.         else  
  62.         {  
  63.             ReleaseMutex(g_hMutex);  
  64.             break;  
  65.         }  
  66.     }  
  67.     return 0;  
  68. }  

 

 

幾個注意的地方：

(1)互斥量為內核對象，能夠與其他線程或特殊事件取得同步；

(2)速度比臨界區要慢；

(3)互斥量對象與所有其它內核對象的不同之處在於它是被線程所擁有的，互斥量對象除了記錄當前信號狀態外，還要記住此時那個線程擁有它。

(4)這個常來被運用於限制程序啟動次數！

 

 

2.事件 Event

 

 

[cpp]  view plain copy
 
  1. #include <Windows.h>  
  2. #include <iostream>  
  3. using namespace std;  
  4. DWORD WINAPI Thread1(LPVOID lpParmeter);  
  5. DWORD WINAPI Thread2(LPVOID lpParmeter);  
  6. static HANDLE g_hEvent = INVALID_HANDLE_VALUE;  
  7. static int g_iCnt = 100;  
  8. int main()  
  9. {  
  10.     HANDLE hThread1 = INVALID_HANDLE_VALUE;  
  11.     HANDLE hThread2 = INVALID_HANDLE_VALUE;  
  12.     g_hEvent = CreateEvent(NULL, false, false, "Event");  
  13.     if (!g_hEvent)  
  14.     {  
  15.         cout << "Failed to CreateEvent !" << endl;  
  16.         return 0;  
  17.     }  
  18.     /*HANDLE CreateEvent( 
  19.     LPSECURITY_ATTRIBUTES lpEventAttributes,    // SECURITY_ATTRIBUTES結構指針，可為NULL 
  20.     BOOL bManualReset,                          // 手動/自動 
  21.     　                                           // TRUE： 在WaitForSingleObject后必須手動調用ResetEvent清除信號 
  22.                                             　   // FALSE：在WaitForSingleObject后，系統自動清除事件信號 
  23.     BOOL bInitialState,                         // 初始狀態 
  24.     LPCTSTR lpName                              // 事件的名稱 
  25.     );*/  
  26.     hThread1 = CreateThread(NULL, 0, Thread1, NULL, 0, NULL);  
  27.     hThread2 = CreateThread(NULL, 0, Thread2, NULL, 0, NULL);  
  28.     SetEvent(g_hEvent);  
  29.     Sleep(4000);        // 讓2個線程有足夠的時間執行完操作。  
  30.     CloseHandle(hThread1);  
  31.     CloseHandle(hThread2);  
  32.     system("PAUSE");  
  33.     return 0;  
  34. }  
  35. DWORD WINAPI Thread1(LPVOID lpParmeter)  
  36. {  
  37.     while (true)  
  38.     {  
  39.         // 請求事件對象  
  40.         WaitForSingleObject(g_hEvent, INFINITE);    // INFINITE: 長時間等待，差不多50天左右吧！  
  41.         if (g_iCnt > 0)  
  42.         {  
  43.             Sleep(20);  
  44.             cout << "Thread1:" << g_iCnt-- << endl;  
  45.             SetEvent(g_hEvent);  
  46.         }  
  47.         else  
  48.         {  
  49.             SetEvent(g_hEvent);  
  50.             break;  
  51.         }  
  52.     }  
  53.     return 0;  
  54. }  
  55. DWORD WINAPI Thread2(LPVOID lpParameter)//thread data  
  56. {  
  57.     while (true)  
  58.     {  
  59.         // 請求事件對象  
  60.         WaitForSingleObject(g_hEvent,INFINITE);  
  61.         if (g_iCnt > 0)  
  62.         {  
  63.             Sleep(20);  
  64.             cout << "thread2:" << g_iCnt-- << endl;  
  65.             SetEvent(g_hEvent);  
  66.         }  
  67.         else  
  68.         {  
  69.             SetEvent(g_hEvent);  
  70.             break;  
  71.         }  
  72.     }  
  73.     return 0;  
  74. }  

 

 

幾個注意的地方：

(1).和Mutex使用差不多，只有細微的差別；

(2).可以使用SetEvent或ResetEvent改變其狀態；

(3).在應用程序中任意一處沒有正確的按照規則調用SetEvent或ResetEvent，將達不到同步或互斥的目的;

(4).一般來說，都是利用Event來進行同步，而不是我們這里的讓它來達到互斥;

(5).Event處於無信號狀態時，相關線程或進程退出，系統並不會嘗試將其置為有信號狀態;

 

3.臨界區 CRITICAL_SECTION

 

 

[cpp]  view plain copy
 
  1. #include <Windows.h>  
  2. #include <iostream>  
  3. using namespace std;  
  4. DWORD WINAPI Thread1(LPVOID lpParmeter);  
  5. DWORD WINAPI Thread2(LPVOID lpParmeter);  
  6. CRITICAL_SECTION g_CriticalSection; // 定義  
  7. static int g_iCnt = 100;  
  8. int main()  
  9. {  
  10.     HANDLE hThread1 = INVALID_HANDLE_VALUE;  
  11.     HANDLE hThread2 = INVALID_HANDLE_VALUE;  
  12.     InitializeCriticalSection(&g_CriticalSection);      // 初始化  
  13.     hThread1 = CreateThread(NULL, 0, Thread1, NULL, 0, NULL);  
  14.     hThread2 = CreateThread(NULL, 0, Thread2, NULL, 0, NULL);  
  15.     Sleep(4000);        // 讓2個線程有足夠的時間執行完操作。  
  16.     CloseHandle(hThread1);  
  17.     CloseHandle(hThread2);  
  18.     DeleteCriticalSection(&g_CriticalSection);          // 刪除  
  19.     system("PAUSE");  
  20.     return 0;  
  21. }  
  22. DWORD WINAPI Thread1(LPVOID lpParmeter)  
  23. {  
  24.     while (true)  
  25.     {  
  26.         EnterCriticalSection(&g_CriticalSection);       // 進入臨界區，獲得所有權，其他線程就等待  
  27.         if (g_iCnt > 0)  
  28.         {  
  29.             Sleep(20);  
  30.             cout << "Thread1:" << g_iCnt-- << endl;  
  31.             LeaveCriticalSection(&g_CriticalSection);   // 離開臨界區，釋放所有權  
  32.         }  
  33.         else  
  34.         {  
  35.             LeaveCriticalSection(&g_CriticalSection);  
  36.             break;  
  37.         }  
  38.     }  
  39.     return 0;  
  40. }  
  41. DWORD WINAPI Thread2(LPVOID lpParameter)//thread data  
  42. {  
  43.     while (true)  
  44.     {  
  45.         EnterCriticalSection(&g_CriticalSection);  
  46.         if (g_iCnt > 0)  
  47.         {  
  48.             Sleep(20);  
  49.             cout << "thread2:" << g_iCnt-- << endl;  
  50.             LeaveCriticalSection(&g_CriticalSection);  
  51.         }  
  52.         else  
  53.         {  
  54.             LeaveCriticalSection(&g_CriticalSection);  
  55.             break;  
  56.         }  
  57.     }  
  58.     return 0;  
  59. }  

 

 

幾個注意的地方：

(1).比Mutex速度快；

(2).臨界區在線程內的分配必須是全局的；

(3). 臨界區一次只允許一個線程訪問;

 

 

4.信號量Semaphore

    首先說說那些關於信號量那些不得不讓人傷心的事情，因為筆者大學不好學習，非常調皮，而信號量又是老師最討論及考試的話題之一，所以我覺得這個東西非常扯淡，非常影響情緒，於是放在最后。------以上是為題外話。

    為什么大學老師總是喜歡信號量呢？

    因為這是一個生產者-消費者模型，並且很多計算機問題都可以看做是生產者-消費者的問題，是同步最易理解的模型。

    關於理論上的知識，我就不說了，書里面很多的。

    還有我不是很想實現生產者-消費者的模型，就用其他例子代替了。這個有點不負責任。

 

 

[cpp]  view plain copy
 
  1. #include <Windows.h>  
  2. #include <iostream>  
  3. #include <vector>  
  4. using namespace std;  
  5. DWORD WINAPI Thread1(LPVOID lpParmeter);  
  6. DWORD WINAPI Thread2(LPVOID lpParmeter);  
  7. static HANDLE g_hSemaphore = INVALID_HANDLE_VALUE;; // 定義  
  8. static int g_iCnt = 100;  
  9. int main()  
  10. {  
  11.     HANDLE hThread1 = INVALID_HANDLE_VALUE;  
  12.     HANDLE hThread2 = INVALID_HANDLE_VALUE;  
  13.     // HANDLE CreateSemaphore (  
  14.     //  PSECURITY_ATTRIBUTE psa,  
  15.     //  LONG lInitialCount, //開始時可供使用的資源數  
  16.     //  LONG lMaximumCount, //最大資源數  
  17.     //  PCTSTR pszName);  
  18.     g_hSemaphore = CreateSemaphore(NULL, 1, 1, "Semaphore");          
  19.     // 初始化有1個信號量。  
  20.     if (g_hSemaphore == INVALID_HANDLE_VALUE)  
  21.     {  
  22.         cout << "Failed to Create Semaphore!" << endl;  
  23.         return 0;  
  24.     }  
  25.     hThread1 = CreateThread(NULL, 0, Thread1, NULL, 0, NULL);  
  26.     hThread2 = CreateThread(NULL, 0, Thread2, NULL, 0, NULL);  
  27.     Sleep(4000);        // 讓2個線程有足夠的時間執行完操作。  
  28.     CloseHandle(hThread1);  
  29.     CloseHandle(hThread2);  
  30.     system("PAUSE");  
  31.     return 0;  
  32. }  
  33. DWORD WINAPI Thread1(LPVOID lpParmeter)  
  34. {  
  35.     while (true)  
  36.     {  
  37.         WaitForSingleObject(g_hSemaphore, INFINITE);        // 釋放一個信號量  
  38.         if (g_iCnt > 0)  
  39.         {  
  40.             Sleep(20);  
  41.             cout << "Thread1:" << g_iCnt-- << endl;  
  42.             ReleaseSemaphore(g_hSemaphore, 1, NULL);        // 增加一個信號量  
  43.         }  
  44.         else  
  45.         {  
  46.             break;  
  47.         }  
  48.     }  
  49.     return 0;  
  50. }  
  51. DWORD WINAPI Thread2(LPVOID lpParameter)//thread data  
  52. {  
  53.     while (true)  
  54.     {  
  55.         WaitForSingleObject(g_hSemaphore, INFINITE);  
  56.         if (g_iCnt > 0)  
  57.         {  
  58.             Sleep(20);  
  59.             cout << "thread2:" << g_iCnt-- << endl;  
  60.             ReleaseSemaphore(g_hSemaphore, 1, NULL);  
  61.         }  
  62.         else  
  63.         {  
  64.             break;  
  65.         }  
  66.     }  
  67.     return 0;  
  68. }  

 

 

幾個注意的地方：

信號量內核對象對線程的同步方式與前面幾種不同，它允許多個線程在同一時刻訪問某一資源，但是需要限制同一時刻訪問此資源的最大線程數目。

 

 

總結： 線程規模 = CPU 數 * 2 + 1

轉自

https://www.cnblogs.com/fenghuan/p/4864897.html


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 C++多線程，互斥，同步 C++ windows 多線程 互斥鎖 C++多線程同步之Mutex(互斥量) 【多線程】C++ 互斥鎖（mutex）的簡單原理分析 用C++和Windows的互斥對象（Mutex）來實現線程同步鎖 用C++和Windows的互斥對象（Mutex）來實現線程同步鎖 windows多線程同步--互斥量 windows多線程同步互斥--總結 C++線程同步與互斥總結 C++ 11 線程的同步與互斥
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM