1.簡介

condition_variable（條件變量）是 C++11 中提供的一種多線程同步機制，它允許一個或多個線程等待另一個線程發(fā)出通知，以便能夠有效地進行線程同步。

condition_variable 需要與 mutex（互斥鎖）一起使用。當線程需要等待某個條件變成真時，它會獲取一個互斥鎖，然后在條件變量上等待，等待期間會自動釋放互斥鎖。另一個線程在滿足條件后會獲取相同的互斥鎖，并調(diào)用條件變量的 notify_one() 或 notify_all() 函數(shù)來喚醒等待的線程。

條件變量是實現(xiàn)復雜線程同步和通信的重要工具，用于避免線程的忙等待和提高性能。

2.等待函數(shù)

condition_variable 有三個等待函數(shù)：wait()、wait_for() 和 wait_util()。

這三個函數(shù)需要與互斥鎖一起使用，以互斥的方式訪問共享資源，并阻塞線程，等待通知。

wait()

void wait(std::unique_lock<std::mutex>& lock);
template <class Predicate>  void wait (unique_lock<mutex>& lck, Predicate pred);

wait() 函數(shù)用于阻塞線程并等待喚醒。

在調(diào)用 wait() 之前，必須獲取一個獨占鎖（std::unique_lock）并將它傳遞給 wait() 函數(shù)。

如果條件變量當前不滿足，線程將被阻塞，同時釋放鎖，使得其他線程可以繼續(xù)執(zhí)行。

當另一個線程調(diào)用 notify_one() 或 notify_all() 來通知條件變量時，被阻塞的線程將被喚醒，并再次嘗試獲取鎖。

wait() 函數(shù)返回時，鎖會再次被持有。

wait() 函數(shù)有一個帶謂詞的版本，可以簡化對條件的判斷。僅僅有當 pred 條件為 false 時調(diào)用 wait() 才會阻塞當前線程，解決了的喚醒丟失問題。而且在收到其它線程的通知后僅僅有當 pred 為 true 時才會被解除堵塞，解決了虛假喚醒的問題。

用法如下：

std::condition_variable cv;
std::mutex mtx;
bool condition = false;
void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return condition; }); // 等待條件滿足
    // ...
}

wait_for()

template <class Rep, class Period>
cv_status wait_for(std::unique_lock<std::mutex>& lock, const std::chrono::duration<Rep, Period>& rel_time);
template <class Rep, class Period, class Predicate>
bool wait_for (unique_lock<mutex>& lck, const chrono::duration<Rep,Period>& rel_time, Predicate pred);

wait_for() 函數(shù)用于阻塞線程并等待喚醒，但與 wait() 不同，它可以設置一個超時時間。

在調(diào)用 wait_for() 之前，必須獲取一個獨占鎖（std::unique_lock）并將它傳遞給 wait_for() 函數(shù)。

如果條件變量在指定的超時時間內(nèi)變?yōu)闈M足，線程將被喚醒，并且 wait_for() 返回 cv_status::no_timeout。

如果超時時間到期且仍未收到喚醒通知，wait_for() 返回 cv_status::timeout，線程繼續(xù)執(zhí)行。

wait_for() 函數(shù)同樣有一個謂詞版本，用法同 wait() 函數(shù)。

wait_until()

template <class Clock, class Duration>
cv_status wait_until(std::unique_lock<std::mutex>& lock, const std::chrono::time_point<Clock, Duration>& abs_time);
template <class Clock, class Duration, class Predicate>
bool wait_until(unique_lock<mutex>& lck, const chrono::time_point<Clock,Duration>& abs_time, Predicate pred);

wait_until 接受一個絕對時間點作為參數(shù)。

線程將等待直到指定的絕對時間點，如果在該時間點之前條件變量滿足，它將返回并繼續(xù)執(zhí)行。

如果到達指定時間點仍未收到喚醒通知，wait_until 返回 cv_status::timeout，線程繼續(xù)執(zhí)行。

wait_until() 函數(shù)同樣有一個謂詞版本，用法同 wait() 函數(shù)。

3.通知函數(shù)

通知函數(shù)有 notify_one() 和 notify_all()。

這兩個函數(shù)都用于喚醒等待線程，以便它們可以繼續(xù)執(zhí)行。notify_all() 用于廣播通知，以確保所有等待線程都有機會檢查條件是否滿足，而 notify_one() 用于選擇性通知一個等待線程。

notify_one()

void notify_one() noexcept;

notify_one() 用于喚醒等待在條件變量上的單個線程。

如果有多個線程在條件變量上等待，只有其中一個線程會被喚醒，具體是哪個線程 C++ 標準并未明確，所以是不確定的。

被喚醒的線程將嘗試獲取與條件變量關(guān)聯(lián)的互斥鎖，一旦成功獲取鎖，它可以繼續(xù)執(zhí)行。

notify_all()

void notify_all() noexcept;

notify_all() 用于喚醒等待在條件變量上的所有線程。

如果有多個線程在條件變量上等待，所有這些線程都會被喚醒。

喚醒的線程將競爭獲取與條件變量關(guān)聯(lián)的互斥鎖，然后可以繼續(xù)執(zhí)行。

4.注意事項

在使用 condition_variable 時需要注意以下幾點：

1.需要與互斥量一起使用，等待前要鎖定互斥量

std::condition_variable 必須與 std::unique_lock 一起使用，需要在持有 mutex 的情況下調(diào)用 wait() 函數(shù)，以確保在線程等待條件時互斥訪問共享資源，從而避免競態(tài)條件（Race Condition）。共享資源包括等待的條件，以及線程等待隊列。

2.注意虛假喚醒和喚醒丟失

虛假喚醒（spurious wakeup）指一個或多個線程被喚醒，但沒有實際的條件變化或通知發(fā)生。這些線程被認為是"虛假喚醒"。

虛假喚醒通常由操作系統(tǒng)或 C++ 標準庫的實現(xiàn)引發(fā)，這是多線程環(huán)境中的一種正常行為。雖然它可能看起來不合理，但是在某些情況下，它是必要的，因為操作系統(tǒng)或標準庫可能需要在內(nèi)部執(zhí)行一些資源管理或線程調(diào)度操作，這可能導致線程被喚醒。

喚醒丟失（wakeup loss）指發(fā)送方在接收方進入等待狀態(tài)之前發(fā)送通知，結(jié)果就是導致通知消失。

為了解決虛假喚醒和喚醒丟失的問題，需要使用一個變量（通常是 bool 類型的變量）來表示等待的條件，線程在等待前和等待后檢查該條件是否滿足。

3.不要忽略 wait_for 和 wait_until 函數(shù)返回值

wait_for 和 wait_until 函數(shù)的返回值應該被檢查，以判斷是因為超時還是因為被通知而返回。

4.不要在鎖內(nèi)部執(zhí)行耗時操作

盡量避免在鎖內(nèi)部執(zhí)行可能會阻塞或耗時較長的操作，因為這會導致其他線程在等待條件時被阻塞。

5.避免死鎖

確保你的線程同步邏輯不會導致死鎖，例如，不要在持有互斥鎖的情況下調(diào)用可能再次嘗試獲取同一個鎖的函數(shù)。

6.小心使用 std::condition_variable_any

std::condition_variable_any 是通用的條件變量，可以與不同類型的互斥量一起使用。但要小心，因為它的性能可能不如與 std::mutex 直接關(guān)聯(lián)的 std::condition_variable。

總之，在多線程編程中使用 std::condition_variable 時，要謹慎考慮同步邏輯，確保線程安全性，防止死鎖，以及正確處理條件等待和通知。多線程編程通常很復雜，需要仔細思考和測試。

5.使用示例

#include <iostream>   
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mtx; 			// 全局相互排斥鎖。
std::condition_variable cv; // 全局條件變量。
bool ready = false;			// 全局標志位。
void print_id(int id) {
    std::unique_lock <std::mutex> lck(mtx);
    // 假設標志位不為 true, 則等待...
    while (!ready){
        // 當前線程被堵塞，等待被喚醒。
        cv.wait(lck);
    }
    // 線程被喚醒, 繼續(xù)往下運行打印線程編號id。
    std::cout << "thread " << id << std::endl;
}
void go() {
    std::unique_lock<std::mutex> lck(mtx);
    ready = true;       // 設置全局標志位為 true.
    cv.notify_all();    // 喚醒全部線程.
}
int main() {
    std::thread threads[10];
    for (int i = 0; i < 10; ++i) {
        threads[i] = std::thread(print_id, i);
    }
    std::cout << "10 threads ready to race..." << std::endl;
    go();
    // 等待所有線程執(zhí)行完成。
    for (auto& th : threads) {
        th.join();
    }
    return 0;
}

編譯運行輸出：

10 threads ready to race...
thread 0
thread 1
thread 2
thread 9
thread 4
thread 6
thread 5
thread 7
thread 8
thread 3

多次運行結(jié)果是不定的，因為線程調(diào)度的順序是不確定的。

參考文獻

std::condition_variable - cplusplus.com

notify_one() choose which thread to unblock?

c++ - Why ‘wait with predicate’ solves the ‘lost wakeup’ - stackoverflow

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