欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

C++ 互斥鎖原理以及實際使用介紹

 更新時間:2023年04月23日 09:46:58   作者:Thomas_Lbw  
本文主要聊一聊如何使用互斥鎖以及都有哪幾種方式實現(xiàn)互斥鎖。實現(xiàn)互斥,可以有以下幾種方式:互斥量(Mutex)、遞歸互斥量(Recursive Mutex)、讀寫鎖(Read-Write Lock)、條件變量(Condition Variable)。感興趣的同學(xué)可以參考一下

一、互斥原理(mutex)

互斥鎖可以確保在任何時候只有一個線程能夠進入臨界區(qū)。當線程需要進入臨界區(qū)時,它會嘗試獲取互斥鎖的所有權(quán),如果互斥鎖已經(jīng)被其他線程占用,那么當前線程就會進入阻塞狀態(tài),直到互斥鎖被釋放為止。簡單說就是一塊區(qū)域只能被一個線程執(zhí)行。

當一個線程獲取到互斥鎖的所有權(quán)后,它就可以進入臨界區(qū)進行操作,當操作完成后,它需要釋放互斥鎖,讓其他線程有機會進入臨界區(qū)。

下面是一個簡單的互斥鎖的示例代碼,它演示了如何使用 std::mutex 類來保護臨界區(qū):

 
#include <iostream>
#include <thread>
#include <mutex>
 
// 定義互斥鎖
std::mutex g_mutex;
 
// 臨界區(qū)代碼
void critical_section(int thread_id) {
    // 加鎖
    g_mutex.lock();
    // 訪問共享資源
    std::cout << "Thread " << thread_id << " enter critical section." << std::endl;
    // 釋放鎖
    std::this_thread::sleep_for(std::chrono::seconds(5));
    g_mutex.unlock();
}
 
int main() {
    // 創(chuàng)建兩個線程
    std::thread t1(critical_section, 1);
    std::thread t2(critical_section, 2);
    // 等待兩個線程執(zhí)行完成
    t1.join();
    t2.join();
    return 0;
}

main中創(chuàng)建兩個線程去訪問資源,但是其中一個需要等待另一個線程5s釋放后才能訪問,形成對資源的鎖定。

上面的例子使用的是std::mutex實現(xiàn)互斥鎖,需要注意這個互斥鎖的聲明需要相對的全局變量,也就是說對于使用鎖的部分它必須是“全局的”。

二、遞歸互斥量(Recursive Mutex)

C++ 中的遞歸互斥量(Recursive Mutex)是一種特殊的互斥量,它可以被同一個線程多次鎖定,而不會發(fā)生死鎖。遞歸互斥量的實現(xiàn)原理是,在鎖定時維護一個鎖定計數(shù)器,每次解鎖時將計數(shù)器減一,只有當計數(shù)器為 0 時才會釋放鎖。

以下是遞歸互斥量的示例代碼:

#include <iostream>
#include <thread>
#include <mutex>
 
std::recursive_mutex mtx;
 
void foo(int n) {
    mtx.lock();
    std::cout << "Thread " << n << " locked the mutex." << std::endl;
    if (n > 1) {
        foo(n - 1);
    }
    std::cout << "Thread " << n << " unlocked the mutex." << std::endl;
    mtx.unlock();
}
 
int main() {
    std::thread t1(foo, 3);
    std::thread t2(foo, 2);
    t1.join();
    t2.join();
    return 0;
}

在上面的代碼中,我們定義了一個遞歸函數(shù) foo(),它接受一個整數(shù)參數(shù) n,表示當前線程的編號。在函數(shù)中,我們首先使用遞歸互斥量 mtx 鎖定當前線程,然后輸出一條帶有線程編號的信息,接著判斷如果 n 大于 1,則遞歸調(diào)用 foo() 函數(shù),并將參數(shù)減一。最后,我們輸出一條解鎖信息,并將遞歸互斥量解鎖。

在主函數(shù)中,我們創(chuàng)建了兩個線程 t1 和 t2,分別調(diào)用 foo() 函數(shù),并傳入不同的參數(shù)值。由于遞歸互斥量可以被同一個線程多次鎖定,因此在 t1 線程中對 mtx 進行了兩次鎖定,而在 t2 線程中只進行了一次鎖定。

運行結(jié)果:

可以看到,遞歸互斥量可以被同一個線程多次鎖定,并且在解鎖時必須對應(yīng)減少鎖定計數(shù)器。這種機制可以避免死鎖的發(fā)生,但也需要注意使用時的線程安全問題。

三、讀寫鎖(Read-Write Lock)

讀寫鎖(Read-Write Lock)是一種特殊的互斥鎖,用于在多線程環(huán)境下對共享資源進行讀寫操作。它允許多個線程同時讀取共享資源,但只允許一個線程寫入共享資源。讀寫鎖的使用可以提高并發(fā)性能,特別是當讀操作比寫操作頻繁時。

在 C++ 中,讀寫鎖可以通過 std::shared_mutex 類型來實現(xiàn)。下面是一個簡單的示例代碼,演示了如何使用讀寫鎖來保護一個共享的整型變量:

#include <iostream>
#include <thread>
#include <chrono>
#include <shared_mutex>
 
std::shared_mutex rw_lock; // 讀寫鎖
int shared_var = 0; // 共享變量
 
// 寫線程函數(shù)
void writer() {
    for (int i = 0; i < 10; ++i) {
        // 獨占寫鎖
        std::unique_lock<std::shared_mutex> lock(rw_lock);
 
        // 寫共享變量
        ++shared_var;
        std::cout << "Writer thread: write shared_var=" << shared_var << std::endl;
 
        // 等待一段時間
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}
 
// 讀線程函數(shù)
void reader(int id) {
    for (int i = 0; i < 10; ++i) {
        // 共享讀鎖
        std::shared_lock<std::shared_mutex> lock(rw_lock);
 
        // 讀共享變量
        int value = shared_var;
        std::cout << "Reader thread " << id << ": read shared_var=" << value << std::endl;
 
        // 等待一段時間
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}
 
int main() {
    std::thread t1(writer);
    std::thread t2(reader, 1);
    std::thread t3(reader, 2);
    std::thread t4(reader, 3);
    t1.join();
    t2.join();
    t3.join();
    t4.join();
    return 0;
}

在上面的代碼中,我們定義了一個共享變量 shared_var 和一個讀寫鎖 rw_lock。寫線程函數(shù) writer() 獨占寫鎖,對 shared_var 進行自增操作,并輸出當前的值。讀線程函數(shù) reader() 共享讀鎖,讀取 shared_var 的值,并輸出當前的值。所有的線程都會等待一段時間,以模擬實際的操作。

在主函數(shù)中,我們創(chuàng)建了一個寫線程和三個讀線程。由于讀寫鎖的特性,讀線程可以并發(fā)讀取共享變量,而寫線程會獨占寫鎖,只有在寫操作完成之后,讀線程才能再次讀取共享變量。因此,輸出結(jié)果中讀線程的順序可能會有所不同,但是寫線程的操作一定是順序執(zhí)行的。

注意,這里使用 std::unique_lockstd::shared_mutex 類型的對象來獲取獨占寫鎖,使用 std::shared_lockstd::shared_mutex 類型的對象來獲取共享讀鎖。這些鎖對象會在作用域結(jié)束時自動解鎖,避免了手動解鎖的問題。

四、條件變量(Condition Variable)

條件變量(Condition Variable)是一種線程間同步機制,用于在某些特定條件下阻塞或喚醒線程。在 C++ 中,條件變量是通過 std::condition_variable 類來實現(xiàn)的。

下面是一個使用條件變量的示例代碼,其中有兩個線程,一個線程不停地生產(chǎn)數(shù)據(jù),另一個線程則等待數(shù)據(jù),當有數(shù)據(jù)可用時,將數(shù)據(jù)進行消費。

#include <iostream>
#include <thread>
#include <chrono>
#include <queue>
#include <mutex>
#include <condition_variable>
 
std::queue<int> data_queue; // 數(shù)據(jù)隊列
std::mutex data_mutex; // 互斥鎖
std::condition_variable data_cond; // 條件變量
 
// 生產(chǎn)數(shù)據(jù)函數(shù)
void producer() {
    for (int i = 1; i <= 10; ++i) {
        // 生產(chǎn)數(shù)據(jù)
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        std::unique_lock<std::mutex> lock(data_mutex);
        data_queue.push(i);
        std::cout << "Producer thread: produce data " << i << std::endl;
 
        // 喚醒消費線程
        data_cond.notify_one();
    }
}
 
// 消費數(shù)據(jù)函數(shù)
void consumer() {
    while (true) {
        // 等待數(shù)據(jù)
        std::unique_lock<std::mutex> lock(data_mutex);
        data_cond.wait(lock, [] { return !data_queue.empty(); });
 
        // 消費數(shù)據(jù)
        int data = data_queue.front();
        data_queue.pop();
        std::cout << "Consumer thread: consume data " << data << std::endl;
 
        // 檢查是否結(jié)束
        if (data == 10) {
            break;
        }
    }
}
 
int main() {
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join();
    t2.join();
    return 0;
}

在上面的代碼中,我們定義了一個數(shù)據(jù)隊列 data_queue 和一個互斥鎖 data_mutex,同時定義了一個條件變量 data_cond。生產(chǎn)數(shù)據(jù)的函數(shù) producer() 不停地往隊列中添加數(shù)據(jù),每次添加完數(shù)據(jù)之后,通過調(diào)用 data_cond.notify_one() 喚醒等待的消費線程。消費數(shù)據(jù)的函數(shù) consumer() 通過調(diào)用 data_cond.wait(lock, [] { return !data_queue.empty(); }) 來等待數(shù)據(jù),當隊列中有數(shù)據(jù)時,將數(shù)據(jù)從隊列中取出并消費,如果取出的數(shù)據(jù)是最后一個,則退出循環(huán)。

在主函數(shù)中,我們創(chuàng)建了一個生產(chǎn)線程和一個消費線程。生產(chǎn)線程生產(chǎn) 10 個數(shù)據(jù),消費線程從隊列中消費數(shù)據(jù),直到消費到最后一個數(shù)據(jù)為止。

注意,這里使用了 std::unique_lockstd::mutex 類型的對象來獲取互斥鎖,并使用 lambda 表達式 [] { return !data_queue.empty(); } 來判斷條件是否滿足。在調(diào)用 wait() 函數(shù)時,當前線程會阻塞,直到條件變量被其他線程喚醒或超時。當 wait() 函數(shù)返回時,當前線程會重新獲取互斥。

簡單一些的例子:

#include <iostream>
#include <thread>
#include <chrono>
#include <mutex>
#include <condition_variable>
 
bool ready = false; // 條件變量
std::mutex data_mutex; // 互斥鎖
std::condition_variable data_cond; // 條件變量
 
void do_something() {
    // 模擬工作
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
}
 
void waiting_thread() {
    // 等待條件變量
    std::unique_lock<std::mutex> lock(data_mutex);
    data_cond.wait(lock, [] { return ready; });
 
    // 條件滿足后輸出一句話
    std::cout << "Condition satisfied, waiting thread resumes." << std::endl;
    do_something();
}
 
int main() {
    std::thread t1(waiting_thread);
 
    // 模擬條件滿足后的操作
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    {
        std::lock_guard<std::mutex> lock(data_mutex);
        ready = true;
        data_cond.notify_one();
    }
 
    t1.join();
    return 0;
}

在上面的代碼中,我們定義了一個條件變量 ready 和一個互斥鎖 data_mutex,同時定義了一個條件變量 data_cond。等待條件變量的函數(shù) waiting_thread() 首先獲取互斥鎖,然后通過調(diào)用 data_cond.wait(lock, [] { return ready; }) 等待條件變量,當 ready 為 true 時,線程會被喚醒,輸出一句話,并模擬一些工作的操作。在主函數(shù)中,我們創(chuàng)建了一個等待條件變量的線程 t1,然后模擬條件滿足后的操作,即將 ready 設(shè)置為 true,然后通過調(diào)用 data_cond.notify_one() 喚醒等待的線程。 

五、總結(jié)

互斥鎖保證了計算機資源訪問的安全,互斥鎖的不當使用同時也加大了程序阻塞的風(fēng)險。

提前祝大家五一前工作生活學(xué)習(xí)一切順利。

到此這篇關(guān)于C++ 互斥鎖原理以及實際使用介紹的文章就介紹到這了,更多相關(guān)C++ 互斥鎖原理及使用內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家!

相關(guān)文章

最新評論