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

更新時間：2023年04月23日 09:46:58 作者：Thomas_Lbw

本文主要聊一聊如何使用互斥鎖以及都有哪幾種方式實現(xiàn)互斥鎖。實現(xiàn)互斥，可以有以下幾種方式：互斥量（Mutex）、遞歸互斥量（Recursive Mutex）、讀寫鎖（Read-Write Lock）、條件變量（Condition Variable）。感興趣的同學可以參考一下

一、互斥原理（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é)果：

可以看到，遞歸互斥量可以被同一個線程多次鎖定，并且在解鎖時必須對應減少鎖定計數(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 設置為 true，然后通過調(diào)用 data_cond.notify_one() 喚醒等待的線程。