示例詳解C++中的各種鎖

更新時間：2024年11月06日 08:53:45 作者：Arthurian

C++中常見的鎖包括互斥鎖、遞歸互斥鎖、讀寫鎖、定時互斥鎖、遞歸定時互斥鎖、自旋鎖和條件變量,互斥鎖用于防止多線程同時訪問共享資源,遞歸互斥鎖允許同一線程多次獲取鎖,讀寫鎖區(qū)分讀寫操作,提高并發(fā)性

互斥鎖（std::mutex）
遞歸互斥鎖（std::recursive_mutex）
讀寫鎖（std::shared_mutex） C++17開始才有
定時互斥鎖（std::timed_mutex）
遞歸定時互斥鎖（std::recursive_timed_mutex）
自旋鎖（通常用std::atomic_flag實現(xiàn)）
條件變量（std::condition_variable）配合互斥鎖用于同步（嚴格來說條件變量不是鎖，但常一起用于線程同步場景）

在多線程開發(fā)中，經(jīng)常會遇到數(shù)據(jù)同步，很多情況下用鎖都是一個很好的選擇。C++中常用的鎖主要有下面幾種：

互斥鎖（std::mutex）

這是最基本的一種鎖。它用于保護共享資源，在任意時刻，最多只有一個線程可以獲取該鎖，從而訪問被保護的資源。當(dāng)一個線程獲取了互斥鎖后，其他試圖獲取該鎖的線程會被阻塞，直到持有鎖的線程釋放它。
例如，在一個多線程程序中，如果多個線程需要訪問和修改同一個全局變量，就可以使用互斥鎖來確保在同一時間只有一個線程能夠進行修改操作，避免數(shù)據(jù)競爭導(dǎo)致的錯誤結(jié)果。

#include <iostream>
#include <mutex>
#include <thread>
std::mutex m;
int counter = 0;
void increment() {
    m.lock();
    counter++;
    std::cout << "Counter value in thread " << std::this_thread::get_id() << " is " << counter << std::endl;
    m.unlock();
}
int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    return 0;
}

遞歸互斥鎖（std::recursive_mutex）

遞歸互斥鎖允許同一個線程多次獲取該鎖。它內(nèi)部會記錄鎖的獲取次數(shù)，每獲取一次，計數(shù)加 1，每次釋放鎖時，計數(shù)減 1，當(dāng)計數(shù)為 0 時，鎖才真正被釋放，可供其他線程獲取。
假設(shè)在一個復(fù)雜的函數(shù)調(diào)用鏈中，函數(shù) A 調(diào)用函數(shù) B，函數(shù) B 又調(diào)用函數(shù) A，并且這些函數(shù)都需要訪問同一個受保護的資源。如果使用普通互斥鎖，就會出現(xiàn)死鎖，而遞歸互斥鎖就可以避免這種情況，因為它允許同一線程多次獲取鎖。

#include <iostream>
#include <mutex>
#include <thread>
std::recursive_mutex rm;
void recursiveFunction(int count) {
    rm.lock();
    if (count > 0) {
        std::cout << "Recursive call with count = " << count << std::endl;
        recursiveFunction(count - 1);
    }
    rm.unlock();
}
int main() {
    std::thread t(recursiveFunction, 3);
    t.join();
    return 0;
}

讀寫鎖（std::shared_mutex） C++17開始才有

讀寫鎖主要用于區(qū)分對共享資源的讀操作和寫操作。它有兩種獲取模式：共享模式（讀模式）和獨占模式（寫模式）。
多個線程可以同時以共享模式獲取讀寫鎖，這意味著它們可以同時讀取共享資源，而不會相互干擾。但是，當(dāng)一個線程要以獨占模式獲取讀寫鎖（進行寫操作）時，其他線程（無論是讀操作還是寫操作）都不能獲取該鎖，直到寫操作完成并釋放鎖。這種機制在有大量讀操作和少量寫操作的場景下，可以提高程序的并發(fā)性能。例如，在一個緩存系統(tǒng)中，多個線程可能經(jīng)常讀取緩存中的數(shù)據(jù)，只有在緩存數(shù)據(jù)需要更新時才會進行寫操作，使用讀寫鎖可以很好地處理這種情況。

#include <iostream>
#include <shared_mutex>
#include <thread>
#include <vector>
std::shared_mutex smtx;
int shared_data = 0;
void read_data() {
    std::shared_lock<std::shared_mutex> lock(smtx);
    std::cout << "Read data: " << shared_data << std::endl;
}
void write_data(int new_value) {
    std::unique_lock<std::shared_mutex> lock(smtx);
    shared_data = new_value;
    std::cout << "Wrote data: " << shared_data << std::endl;
}
int main() {
    std::vector<std::thread> read_threads;
    for (int i = 0; i < 5; i++) {
        read_threads.push_back(std::thread(read_data));
    }
    std::thread write_thread(write_data, 10);
    for (auto& t : read_threads) {
        t.join();
    }
    write_thread.join();
    return 0;
}

定時互斥鎖（std::timed_mutex）

定時互斥鎖是std::mutex的擴展。除了具備std::mutex的基本功能外，它還允許線程在嘗試獲取鎖時設(shè)置一個超時時間。
如果在規(guī)定的超時時間內(nèi)無法獲取鎖，線程不會一直等待，而是可以執(zhí)行其他操作或者返回錯誤信息。這在一些對時間敏感的場景中非常有用，比如在一個實時系統(tǒng)中，線程不能因為等待一個鎖而無限期地阻塞，需要在一定時間后放棄獲取并進行其他處理。

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
std::timed_mutex tm;
void tryLockFunction() {
    if (tm.try_lock_for(std::chrono::seconds(1))) {
        std::cout << "Acquired lock" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(2));
        tm.unlock();
    } else {
        std::cout << "Could not acquire lock in time" << std::endl;
    }
}
int main() {
    std::thread t1(tryLockFunction);
    std::thread t2(tryLockFunction);
    t1.join();
    t2.join();
    return 0;
}

遞歸定時互斥鎖（std::recursive_timed_mutex）

這是結(jié)合了遞歸互斥鎖和定時互斥鎖特點的一種鎖。它允許同一線程多次獲取鎖，并且在獲取鎖時可以設(shè)置超時時間。
當(dāng)一個線程多次獲取這種鎖后，需要釋放相同次數(shù)的鎖，鎖才會真正被釋放，并且在獲取鎖的過程中，如果在超時時間內(nèi)無法獲取，線程可以采取相應(yīng)的措施。

#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
std::recursive_timed_mutex rtm;
void recursiveTryLockFunction(int count) {
    if (rtm.try_lock_for(std::chrono::seconds(1))) {
        std::cout << "Recursive acquired lock, count = " << count << std::endl;
        if (count > 0) {
            recursiveTryLockFunction(count - 1);
        }
        rtm.unlock();
    } else {
        std::cout << "Could not recursively acquire lock in time" << std::endl;
    }
}
int main() {
    std::thread t(recursiveTryLockFunction, 3);
    t.join();
    return 0;
}

自旋鎖（通常用std::atomic_flag實現(xiàn)）

自旋鎖是一種忙等待的鎖機制。當(dāng)一個線程嘗試獲取自旋鎖而鎖已經(jīng)被占用時，這個線程不會進入阻塞狀態(tài)，而是會不斷地檢查（“自旋”）鎖是否已經(jīng)被釋放。
自旋鎖在等待時間較短的情況下可能會有比較好的性能表現(xiàn)，因為它避免了線程切換的開銷。但是，如果等待時間過長，由于線程一直在占用 CPU 資源進行檢查，會導(dǎo)致 CPU 資源的浪費。一般在底層代碼或者對性能要求極高、等待時間預(yù)計很短的場景下使用。

#include <iostream>
#include <atomic>
#include <thread>
std::atomic_flag spinLock = ATOMIC_FLAG_INIT;
void criticalSection() {
    while (spinLock.test_and_set()) {
        // 自旋等待
    }
    std::cout << "Entered critical section" << std::endl;
    // 臨界區(qū)操作
    spinLock.clear();
}
int main() {
    std::thread t1(criticalSection);
    std::thread t2(criticalSection);
    t1.join();
    t2.join();
    return 0;
}

條件變量（std::condition_variable）配合互斥鎖用于同步（嚴格來說條件變量不是鎖，但常一起用于線程同步場景）

條件變量本身不是一種鎖，但它通常和互斥鎖一起使用，用于實現(xiàn)線程間的同步。它可以讓一個線程等待某個條件滿足后再繼續(xù)執(zhí)行。
例如，一個生產(chǎn)者 - 消費者模型中，消費者線程在緩沖區(qū)為空時可以使用條件變量等待，直到生產(chǎn)者線程生產(chǎn)出產(chǎn)品并通知消費者線程，這個過程中互斥鎖用于保護緩沖區(qū)這個共享資源，條件變量用于實現(xiàn)線程間的通信和同步。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
std::mutex mtx;
std::condition_variable cv;
std::queue<int> buffer;
const int bufferSize = 5;
void producer() {
    for (int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        while (buffer.size() == bufferSize) {
            cv.wait(lock);
        }
        buffer.push(i);
        std::cout << "Produced: " << i << std::endl;
        cv.notify_all();
    }
}
void consumer() {
    for (int i = 0; i < 10; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        while (buffer.empty()) {
            cv.wait(lock);
        }
        int data = buffer.front();
        buffer.pop();
        std::cout << "Consumed: " << data << std::endl;
        cv.notify_all();
    }
}
int main() {
    std::thread producerThread(producer);
    std::thread consumerThread(consumer);
    producerThread.join();
    consumerThread.join();
    return 0;
}

到此這篇關(guān)于C++中的各種鎖的文章就介紹到這了,更多相關(guān)C++ 各種鎖內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: