2. 程式人生 > >C++執行緒同步的四種方式（Windows）

C++執行緒同步的四種方式（Windows）

阿新 • • 發佈：2019-01-04

為什麼要進行執行緒同步？

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

程式碼示例：
兩個執行緒同時對一個全域性變數進行加操作，演示了多執行緒資源訪問衝突的情況。

#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;
}

執行結果：
這裡寫圖片描述
可以看到，實現了有序輸出，實現了執行緒同步。

相關推薦

C++執行緒同步的四種方式（Windows）

為什麼要進行執行緒同步？ 　　在程式中使用多執行緒時，一般很少有多個執行緒能在其生命期內進行完全獨立的操作。更多的情況是一些執行緒進行某些處理操作，而其他的執行緒必須對其處理結果進行了解。正常情況下對這種處理結果的瞭解應當在其處理任務完成後進行。 　　如果不

java建立執行緒的四種方法（轉）

java中建立執行緒的四種方法以及區別 Java使用Thread類代表執行緒，所有的執行緒物件都必須是Thread類或其子類的例項。Java可以用四種方式來建立執行緒，如下所示： 1）繼承Thread類建立執行緒 2）實現Runnable介面建立執行緒 3）使用Callable和Future建立執行緒

執行緒狀態，開啟子執行緒的3種方式（Callable）

（理理基礎是很有必要的） 先看一張非常好的圖 注意，當你start一個執行緒，他只是處於可執行狀態，不一定會立刻執行，這取決於作業系統分配給你的時間 建立方式1，繼承Thread class MyThread extends Thread { @Overri

執行緒同步的四種方式（一）

併發concurent與並行parallel的區別： 互斥物件 首先我們需要建立CreateMutex一把互斥物件，我們可以指明當前執行緒是否擁有它，互斥物件完全就像一把鑰匙一樣，我們用WaitForSignalObject來等待這把鑰匙，但是這把鑰匙被等到

C# 中關閉當前執行緒的四種方式

從查MSDN和從網上查資料可以知道，Dispose()方法，雖然能釋放當前窗體的資源，卻不能強制結束迴圈， 要想強制突出當前程式要用：System.Environment.Exit(int exitcode)方法；該方法：終止當前程序併為基礎作業系統提供指定的退出程式碼。 如下則問題解決： private v

執行shell指令碼的四種方式（轉）

原文網址：https://www.jb51.net/article/53924.htm 這篇文章主要介紹了Linux中執行shell指令碼的4種方法,即總結在Linux中執行shell指令碼的4種方法。 前提：bash shell 指令碼的方法有多種，現在作個小結。假設我們編寫好的shell指令碼的檔名為

java執行緒同步5種方式

 java允許多執行緒併發控制，當多個執行緒同時操作一個可共享的資源變數時（如資料的增刪改查），      將會導致資料不準確，相互之間產生衝突，因此加入同步鎖以避免在該執行緒沒有完成操作之前，被其他執行緒的呼叫，      從而保證了該變數的唯一性和準確性。 1

Android啟動執行緒的四種方式

Android開發當中，經常都需要開啟子執行緒來進行一些耗時，或者可能產生阻塞的操作。開啟子執行緒主要分開兩大方式，繼承Thread類，或者是實現runnable類。不多說，看程式碼： 1、繼承Thread類的實現： 首先要寫一個子執行緒類，去繼承Thread類，重寫ru

4. 執行緒同步幾種方式

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

iOS 執行緒同步幾種方式

多執行緒同步目的有以下幾個方面：第一，對一段程式碼的執行進行保護，如果同時執行一段程式碼，中間的臨時變數可能會互相干擾造成結果不對；第二，對資源的保護，多個執行緒執行不同的程式碼，但是可能涉及同一個資源；第三，訊息傳遞，一個執行緒通知另外一個執行緒發生了一件事。

java建立執行緒的四種方式

參考自：http://blog.csdn.net/longshengguoji/article/details/41126119 java建立執行緒的三種方式 1. 繼承Thread類建立執行緒類 package com.thread; p

Java建立多執行緒的四種方式

在進行講解執行緒的建立方式之前，首先了解下什麼是程序，什麼是執行緒，程序與執行緒之間的關係等 什麼是程序？ 其實當一個程式進入記憶體執行時，就是一個程序，程序是處於執行中的程式，並且具有一定的獨立功能，程序是系統進行資源分配和排程的一個獨立單位，具有獨立性，動態性，併發性，這裡的獨立性指的是在系統中獨立存在，

2_本地直播平臺的搭建—四種方式（20181116）

本地直播平臺的搭建—五種方式 方法一：Windows下用FFmpeg+nginx+rtmp搭建直播環境 實現推流、拉流 （`測試通過`） 環境 1. 簡介： 2. 準備檔案 3. 啟動nginx伺服器 4. 配置FFmpe

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

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

Spring配置資料來源的四種方式（小結）

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSc

執行緒同步與死鎖（3）

執行緒同步與死鎖 1、多執行緒共享資料 在多執行緒操作中，多個執行緒有可能同時處理同一個資源，這就是多執行緒中的共享資料 2、執行緒同步 解決資料共享問題必須使用同步，所謂的同步就是指多個執行緒在同一個時間段內只能有一個執行緒執行指定的程式

Python基礎（四）--- Python多執行緒介紹，開啟執行緒的三種方式，time模組，join，Daemon，Lock、Rlock，事件機制，Timer

一、多執行緒介紹 --------------------------------------------------------- 1.threading用於提供執行緒相關的操作，執行緒是應用程式中工作的最小單元。 2.python當前版本的多執行緒庫沒有實現優先順序、執行緒組，執

Java第十三天學習筆記~多執行緒（執行緒的狀態、建立執行緒的第二種方式、同步程式碼塊、同步函式）

                                 多執行緒 執行緒的狀態 CPU的執行資格：可以被C

java執行緒同步的5種方式（轉載）

為何要使用同步？      java允許多執行緒併發控制，當多個執行緒同時操作一個可共享的資源變數時（如資料的增刪改查），      將會導致資料不準確，相互之間產生衝突，因此加入同步鎖以避免在該執行緒沒有完成操作之前，被其他執行緒的呼叫，      從而保證了該變數

Python多工（2.執行緒(建立執行緒的兩種方式)）

Python中threading模組 可以總結出：    （1）當呼叫Thread的時候，不會建立執行緒 （2）呼叫Thread創建出來的例項物件的start方法的時候，才會建立執行緒以及讓這個執行緒開始執行