C++線程同步的四種方式（Windows）

本文轉載自查看原文 2018-07-15 22:22 10799 C

為什么要進行線程同步？

　　在程序中使用多線程時，一般很少有多個線程能在其生命期內進行完全獨立的操作。更多的情況是一些線程進行某些處理操作，而其他的線程必須對其處理結果進行了解。正常情況下對這種處理結果的了解應當在其處理任務完成后進行。
　　如果不采取適當的措施，其他線程往往會在線程處理任務結束前就去訪問處理結果，這就很有可能得到有關處理結果的錯誤了解。例如，多個線程同時訪問同一個全局變量，如果都是讀取操作，則不會出現問題。如果一個線程負責改變此變量的值，而其他線程負責同時讀取變量內容，則不能保證讀取到的數據是經過寫線程修改后的。
　　為了確保讀線程讀取到的是經過修改的變量，就必須在向變量寫入數據時禁止其他線程對其的任何訪問，直至賦值過程結束后再解除對其他線程的訪問限制。這種保證線程能了解其他線程任務處理結束后的處理結果而采取的保護措施即為線程同步。

代碼示例：
兩個線程同時對一個全局變量進行加操作，演示了多線程資源訪問沖突的情況。

#include "stdafx.h"
#include<windows.h>
#include<iostream>
using namespace std;

int number = 1;

unsigned long __stdcall ThreadProc1(void* lp)
{
    while (number < 100)
    {
        cout << "thread 1 :"<<number << endl;
        ++number;
        _sleep(100);
    }

    return 0;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
    while (number < 100)
    {
        cout << "thread 2 :"<<number << endl;
        ++number;
        _sleep(100);
    }

    return 0;
}

int main()
{
    CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
    CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);

    Sleep(10*1000);

    system("pause");
    return 0;
}

運行結果：
這里寫圖片描述
可以看到有時兩個線程計算的值相同，不是我們想要的結果。

關於線程同步

線程之間通信的兩個基本問題是互斥和同步。

線程同步是指線程之間所具有的一種制約關系，一個線程的執行依賴另一個線程的消息，當它沒有得到另一個線程的消息時應等待，直到消息到達時才被喚醒。
線程互斥是指對於共享的操作系統資源（指的是廣義的”資源”，而不是Windows的.res文件，譬如全局變量就是一種共享資源），在各線程訪問時的排它性。當有若干個線程都要使用某一共享資源時，任何時刻最多只允許一個線程去使用，其它要使用該資源的線程必須等待，直到占用資源者釋放該資源。

線程互斥是一種特殊的線程同步。實際上，互斥和同步對應着線程間通信發生的兩種情況：

當有多個線程訪問共享資源而不使資源被破壞時；
當一個線程需要將某個任務已經完成的情況通知另外一個或多個線程時。

從大的方面講，線程的同步可分用戶模式的線程同步和內核對象的線程同步兩大類。

用戶模式中線程的同步方法主要有原子訪問和臨界區等方法。其特點是同步速度特別快，適合於對線程運行速度有嚴格要求的場合。
內核對象的線程同步則主要由事件、等待定時器、信號量以及信號燈等內核對象構成。由於這種同步機制使用了內核對象，使用時必須將線程從用戶模式切換到內核模式，而這種轉換一般要耗費近千個CPU周期，因此同步速度較慢，但在適用性上卻要遠優於用戶模式的線程同步方式。

在WIN32中，同步機制主要有以下幾種：
（1）事件(Event);
（2）信號量(semaphore);
（3）互斥量(mutex);
（4）臨界區(Critical section)。

Win32中的四種同步方式

臨界區

臨界區（Critical Section）是一段獨占對某些共享資源訪問的代碼，在任意時刻只允許一個線程對共享資源進行訪問。如果有多個線程試圖同時訪問臨界區，那么在有一個線程進入后其他所有試圖訪問此臨界區的線程將被掛起，並一直持續到進入臨界區的線程離開。臨界區在被釋放后，其他線程可以繼續搶占，並以此達到用原子方式操作共享資源的目的。

臨界區在使用時以CRITICAL_SECTION結構對象保護共享資源，並分別用EnterCriticalSection（）和LeaveCriticalSection（）函數去標識和釋放一個臨界區。所用到的CRITICAL_SECTION結構對象必須經過InitializeCriticalSection（）的初始化后才能使用，而且必須確保所有線程中的任何試圖訪問此共享資源的代碼都處在此臨界區的保護之下。否則臨界區將不會起到應有的作用，共享資源依然有被破壞的可能。

代碼示例：

#include "stdafx.h"
#include<windows.h>
#include<iostream>
using namespace std;

int number = 1; //定義全局變量
CRITICAL_SECTION Critical;      //定義臨界區句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
    while (number < 100)
    {
        EnterCriticalSection(&Critical);
        cout << "thread 1 :"<<number << endl;
        ++number;
        _sleep(100);
        LeaveCriticalSection(&Critical);
    }

    return 0;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
    while (number < 100)
    {
        EnterCriticalSection(&Critical);
        cout << "thread 2 :"<<number << endl;
        ++number;
        _sleep(100);
        LeaveCriticalSection(&Critical);
    }

    return 0;
}

int main()
{
    InitializeCriticalSection(&Critical);   //初始化臨界區對象

    CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
    CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);

    Sleep(10*1000);

    system("pause");
    return 0;
}

運行結果：
這里寫圖片描述
可以看到，也實現了有序輸出，實現了線程同步。

事件

事件(Event)是WIN32提供的最靈活的線程間同步方式，事件可以處於激發狀態(signaled or true)或未激發狀態(unsignal or false)。根據狀態變遷方式的不同，事件可分為兩類：
（1）手動設置：這種對象只可能用程序手動設置，在需要該事件或者事件發生時，采用SetEvent及ResetEvent來進行設置。
（2）自動恢復：一旦事件發生並被處理后，自動恢復到沒有事件狀態，不需要再次設置。

使用”事件”機制應注意以下事項：
（1）如果跨進程訪問事件，必須對事件命名，在對事件命名的時候，要注意不要與系統命名空間中的其它全局命名對象沖突；
（2）事件是否要自動恢復；
（3）事件的初始狀態設置。

由於event對象屬於內核對象，故進程B可以調用OpenEvent函數通過對象的名字獲得進程A中event對象的句柄，然后將這個句柄用於ResetEvent、SetEvent和WaitForMultipleObjects等函數中。此法可以實現一個進程的線程控制另一進程中線程的運行，例如：

HANDLE hEvent=OpenEvent(EVENT_ALL_ACCESS,true,"MyEvent"); 
ResetEvent(hEvent);

代碼示例：

#include "stdafx.h"
#include<windows.h>
#include<iostream>
using namespace std;

int number = 1; //定義全局變量
HANDLE hEvent;  //定義事件句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
    while (number < 100)
    {
        WaitForSingleObject(hEvent, INFINITE);  //等待對象為有信號狀態
        cout << "thread 1 :"<<number << endl;
        ++number;
        _sleep(100);
        SetEvent(hEvent);
    }

    return 0;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
    while (number < 100)
    {
        WaitForSingleObject(hEvent, INFINITE);  //等待對象為有信號狀態
        cout << "thread 2 :"<<number << endl;
        ++number;
        _sleep(100);
        SetEvent(hEvent);
    }

    return 0;
}

int main()
{
    CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
    CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);
    hEvent = CreateEvent(NULL, FALSE, TRUE, "event");

    Sleep(10*1000);

    system("pause");
    return 0;
}

運行結果：
這里寫圖片描述
可以看到，實現了有序輸出，實現了線程同步。

信號量

信號量是維護0到指定最大值之間的同步對象。信號量狀態在其計數大於0時是有信號的，而其計數是0時是無信號的。信號量對象在控制上可以支持有限數量共享資源的訪問。

信號量的特點和用途可用下列幾句話定義：
（1）如果當前資源的數量大於0，則信號量有效；
（2）如果當前資源數量是0，則信號量無效；
（3）系統決不允許當前資源的數量為負值；
（4）當前資源數量決不能大於最大資源數量。

創建信號量

函數原型為：

HANDLE CreateSemaphore (
  　PSECURITY_ATTRIBUTE psa, //信號量的安全屬性
　  LONG lInitialCount, //開始時可供使用的資源數
　  LONG lMaximumCount, //最大資源數
   PCTSTR pszName);     //信號量的名稱

釋放信號量

通過調用ReleaseSemaphore函數，線程就能夠對信標的當前資源數量進行遞增，該函數原型為：

BOOL WINAPI ReleaseSemaphore(
  　HANDLE hSemaphore,   //要增加的信號量句柄
  　LONG lReleaseCount, //信號量的當前資源數增加lReleaseCount
  　LPLONG lpPreviousCount  //增加前的數值返回
   );

打開信號量　

和其他核心對象一樣，信號量也可以通過名字跨進程訪問，打開信號量的API為：

HANDLE OpenSemaphore (
  　DWORD fdwAccess,      //access
  　BOOL bInherithandle,  //如果允許子進程繼承句柄，則設為TRUE
  　PCTSTR pszName  //指定要打開的對象的名字
  );

代碼示例：

#include "stdafx.h"
#include<windows.h>
#include<iostream>
using namespace std;

int number = 1; //定義全局變量
HANDLE hSemaphore;  //定義信號量句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
    long count;
    while (number < 100)
    {
        WaitForSingleObject(hSemaphore, INFINITE);  //等待信號量為有信號狀態
        cout << "thread 1 :"<<number << endl;
        ++number;
        _sleep(100);
        ReleaseSemaphore(hSemaphore, 1, &count);
    }

    return 0;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
    long count;
    while (number < 100)
    {
        WaitForSingleObject(hSemaphore, INFINITE);  //等待信號量為有信號狀態
        cout << "thread 2 :"<<number << endl;
        ++number;
        _sleep(100);
        ReleaseSemaphore(hSemaphore, 1, &count);
    }

    return 0;
}

int main()
{
    hSemaphore = CreateSemaphore(NULL, 1, 100, "sema");

    CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
    CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);

    Sleep(10*1000);

    system("pause");
    return 0;
}

運行結果：
這里寫圖片描述
可以看到，實現了有序輸出，實現了線程間同步。

互斥量

采用互斥對象機制。只有擁有互斥對象的線程才有訪問公共資源的權限，因為互斥對象只有一個，所以能保證公共資源不會同時被多個線程訪問。互斥不僅能實現同一應用程序的公共資源安全共享，還能實現不同應用程序的公共資源安全共享。

代碼示例：

#include "stdafx.h"
#include<windows.h>
#include<iostream>
using namespace std;

int number = 1; //定義全局變量
HANDLE hMutex;  //定義互斥對象句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
    while (number < 100)
    {
        WaitForSingleObject(hMutex, INFINITE);
        cout << "thread 1 :"<<number << endl;
        ++number;
        _sleep(100);
        ReleaseMutex(hMutex);
    }

    return 0;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
    while (number < 100)
    {
        WaitForSingleObject(hMutex, INFINITE);
        cout << "thread 2 :"<<number << endl;
        ++number;
        _sleep(100);
        ReleaseMutex(hMutex);
    }

    return 0;
}

int main()
{
    hMutex = CreateMutex(NULL, false, "mutex");     //創建互斥對象

    CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
    CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);

    Sleep(10*1000);

    system("pause");
    return 0;
}

運行結果：
這里寫圖片描述
可以看到，實現了有序輸出，實現了線程同步。

參考資料：
[1] http://blog.jobbole.com/109200/
[2] http://xiaoruanjian.iteye.com/blog/1092117

[3]https://blog.csdn.net/s_lisheng/article/details/74278765

免責聲明！

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

猜您在找 C++ 線程同步的四種方式 Windows線程同步的四種方式四種方式創建c++線程 linux多線程同步的四種方式【Linux】多線程同步的四種方式關於windows線程同步的四種方法 C#開啟線程的四種方式 C#開啟線程的四種方式【C#】創建線程的四種方式 C++對象賦值的四種方式