呼和浩特市城乡建设委员的网站/文明seo技术教程网

1. 上个章节我们讨论了如何对共享数据的一个保护，通过std::lock_guard、std::unique_lock、初始化过程中使用std::call_once、std::once_flag、多个线程读取少量线程写入的时候使用std::shared_lock、std::unique_lock和std::shared_mutex或std::shared_timed_mutex搭配使用，还有单线程递归加锁的方式std::recursive_mutex的使用方法。
2. 但是有时候我们不仅需要保护共享数据，还需要令独立线程上的行为同步。那么本章节我们就来讲一下线程同步的几种方法。

1. 等待事件或等待其他条件

有的时候需要各个线程之间协同操作，比如A线程需要等待B线程完成某一个功能之后才开始执行，那么有没有什么办法，B线程完成功能之后通知A线程一声，然后A线程接受到信号之后就开始工作呢？肯定是有的。

1.1 凭借条件变量等待条件成立

那么就开始介绍std::condition_variable 和 std::condition_variable_any的使用。
std::condition_variable 和 std::condition_variable_any 是 C++ 中用于多线程同步的两个类。它们都允许线程在等待某个条件变为真之前挂起自己，以免造成无谓的 CPU 时间浪费。

1.1.1 std::condition_variable

std::condition_variable 是 C++11 中引入的一个线程同步原语，用于在等待某个条件变为真之前挂起当前线程。使用 std::condition_variable 时，通常需要先定义一个 std::mutex，因为std::condition_variable仅限于与std::mutex一起使用，然后用 std::unique_lockstd::mutex 对其进行上锁，最后通过 std::condition_variable::wait() 解锁并且挂起当前线程：

#include <iostream>
#include <mutex>
#include <thread>
#include <condition_variable>
std::mutex mtx;
std::condition_variable cv;
bool ready = false;void worker_thread() {// 等待条件变为真std::unique_lock<std::mutex> lck(mtx);while (!ready) {cv.wait(lck);}// 条件已经变为真，执行一些操作// ...if (lck.owns_lock()){std::cout << "lck has locked" << std::endl;}
}int main() {// 模拟某些操作std::this_thread::sleep_for(std::chrono::seconds(5));// 通知等待的线程条件已经变为真{std::lock_guard<std::mutex> lck(mtx);ready = true;}cv.notify_one();std::thread t(worker_thread);t.join();return 0;
}

在上面的代码中，worker_thread() 函数等待 ready 变为 true，如果当前 ready 的值为 false，则调用 cv.wait(lck) 挂起当前线程，同时释放 lck。当 cv.notify_one() 被调用时，cv.wait(lck) 会返回，worker_thread() 函数会重新获得 lck，然后执行一些操作。

需要注意的是，由于 std::condition_variable::wait() 可能会出现虚假唤醒（即没有被 notify 也会从 wait() 函数中返回），因此在使用 std::condition_variable 时，通常需要将等待条件的语句用循环包围起来，以确保条件变为真时不会错过信号。
当然也可以这样写：

#include <iostream>
#include <mutex>
#include <thread>
#include <condition_variable>
std::mutex mtx;
std::condition_variable cv;
bool ready = false;void worker_thread() {// 等待条件变为真std::unique_lock<std::mutex> lck(mtx);cv.wait(lck, [&]() {return ready; }); // 条件已经变为真，执行一些操作// ...if (lck.owns_lock()){std::cout << "lck has locked" << std::endl;}
}int main() {// 模拟某些操作std::this_thread::sleep_for(std::chrono::seconds(5));// 通知等待的线程条件已经变为真{std::lock_guard<std::mutex> lck(mtx);ready = true;}cv.notify_one();std::thread t(worker_thread);t.join();return 0;
}

在段代码里面使用了cv.wait(lock, [&]() { return ready; })进行等待条件成立。正好在此介绍一下std::condition_variable::wait()函数的用法:

std::condition_variable::wait()是一个用于等待通知的函数，其使用方式如下：

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

其中，lock是一个已经加锁的互斥量（必须是 std::unique_lock 类型），pred是一个可调用对象，用于判断等待条件是否满足。函数执行时会自动释放锁，并阻塞当前线程直到被通知。当线程被通知后，函数会重新获得锁，并重新检查等待条件。如果等待条件满足，函数返回；否则，函数再次进入阻塞状态等待下一次通知。

1.1.2 std::condition_variable_any

std::condition_variable_any 是 C++11 中引入的另一个线程同步原语，它的作用与 std::condition_variable 相同，但是可以与任何可锁定的互斥量（std::mutex、std::shared_mutex、std::recursive_mutex）等等一起使用。使用 std::condition_variable_any 时，需要先定义一个互斥量，然后使用 std::unique_lock 对其进行上锁。

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>std::mutex mtx;
std::condition_variable_any cv;
bool ready = false;void worker_thread() {// 等待条件变为真{std::unique_lock<std::mutex> lck(mtx);while (!ready) {cv.wait(lck);}}// 条件已经变为真，执行一些操作// ...std::cout << "shared data" << std::endl;
}int main() {// 模拟某些操作std::this_thread::sleep_for(std::chrono::seconds(1));// 通知等待的线程条件已经变为真{std::lock_guard<std::mutex> lck(mtx);ready = true;}cv.notify_one();std::thread t(worker_thread);t.join();return 0;
}

注意：至于为什么能在main函数中使用std::lock_guard，而在worker_thread()函数中不能使用std::lock_guard，这是因为std::condition_variable或者std::condition_variable_any在等待操作的过程中要释放互斥量，如果使用 std::lock_guard，那么在等待操作期间就无法释放互斥量，从而无法满足 std::condition_variable 的要求。

std::unique_lock 比 std::lock_guard 更灵活，因为它允许在构造时不锁定互斥量，在析构时再解锁。这使得 std::unique_lock 可以用于实现一些更为复杂的同步操作，例如超时等待、可重入锁等。此外，std::unique_lock 还提供了一些额外的功能，例如手动锁定和解锁互斥量、转移互斥量的所有权等。

在使用 std::condition_variable或者std::condition_variable_any时，我们通常需要使用 std::unique_lock 来锁定互斥量，并在等待操作期间释放互斥量。这样可以让其他线程获得互斥量并修改共享变量，从而避免死锁的情况。

1.1.3 std::condition_variable和std::condition_variable_any之间的区别

std::condition_variable 和 std::condition_variable_any 都是用于多线程同步的 C++ 标准库类，它们的主要区别在于：

• 适用范围：
  std::condition_variable 只能与 std::unique_lockstd::mutex 配合使用，而 std::condition_variable_any 可以与任何能够提供 lock() 和 unlock() 成员函数的互斥量配合使用，包括 std::mutex、std::recursive_mutex、std::shared_mutex 等等。
• 实现细节：
  std::condition_variable_any 的实现可能比 std::condition_variable 更为复杂，因为它需要支持不同类型的互斥量，而且可能需要在等待队列中存储更多的信息来避免死锁和无效的等待。

综上所述，std::condition_variable 更为简单且更为常用，适用于绝大多数的同步场景。而 std::condition_variable_any 则更加灵活，适用于一些特殊的同步场景，例如需要使用不同类型的互斥量、需要跨线程进行等待和通知等。