【C++】条件变量（Condition Variable）与互斥锁（Mutex）结合使用实现线程间的协作

1 基本概念

条件变量（Condition Variable）是一种同步机制，用于协调线程之间的操作。它通常与互斥锁（Mutex）结合使用，以实现线程间的协作。

条件变量允许线程在等待某些特定条件时被阻塞，直到其他线程在满足这些条件时通知它们。在等待条件期间，线程可以释放互斥锁，从而允许其他线程访问共享资源，同时避免竞争条件。

当某个线程满足条件时，它可以使用条件变量通知正在等待的线程。在接收到通知后，线程可以重新获取互斥锁，并继续执行。

条件变量在编写多线程应用程序时非常有用，因为它们可以帮助避免死锁，并允许线程在满足特定条件时才进行操作，从而提高应用程序的效率。

2 例子

2.1 代码

#include <iostream>             // 包含输入输出流的头文件
#include <thread>               // 包含线程库的头文件
#include <mutex>                // 包含互斥锁的头文件
#include <condition_variable>   // 包含条件变量的头文件

std::mutex mtx;                 // 定义互斥锁对象 mtx
std::condition_variable cv;     // 定义条件变量对象 cv
bool ready = false;             // 定义共享变量 ready

void worker_thread() {          // 工作线程的入口函数
    std::unique_lock<std::mutex> lock(mtx);   // 创建互斥锁的 RAII 包装类对象 lock
    cv.wait(lock, [] { return ready; });     // 阻塞工作线程，等待条件变量 cv 的通知

    std::cout << "Worker thread is running..." << std::endl;  // 工作线程继续执行
}

int main() {                    // 主线程的入口函数
    std::cout << "Main thread starts..." << std::endl;        // 输出主线程开始执行的消息

    std::thread worker(worker_thread);  // 创建工作线程

    std::this_thread::sleep_for(std::chrono::seconds(1));    // 主线程等待一段时间

    {   // 创建临界区，锁定互斥锁 mtx
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;           // 设置共享变量 ready
    }
    cv.notify_one();            // 通知工作线程，条件变量 cv 发生变化

    worker.join();              // 等待工作线程结束
    std::cout << "Main thread exits..." << std::endl;        // 输出主线程结束执行的消息
    
    return 0;                   // 返回程序退出码
}

2.2 运行过程

每一步的解释如下：

1. 定义互斥锁 mtx、条件变量 cv 和等待条件 ready。
2. 定义工作线程函数 worker_thread()，其中等待主线程发送 ready 信号，一旦接收到信号后输出信息。
3. 在主函数中创建工作线程 worker。
4. 在主函数中使用 std::lock_guard 对互斥锁 mtx 进行加锁，将等待条件 ready 设为真，表示已经准备好，可以开始执行任务了。
5. 使用条件变量的 notify_one() 函数唤醒等待的线程。
6. 等待工作线程 worker 执行完成。
7. 返回 0，表示程序正常结束。

在程序运行时，主线程先通过 std::lock_guard 对互斥锁进行加锁，将等待条件 ready 设为真。接着，主线程使用条件变量的 notify_one() 函数唤醒等待的线程。此时，工作线程接收到信号后被唤醒，继续执行任务，输出信息 Worker thread is processing…。最后，主线程等待工作线程执行完成后，程序正常结束。

3 代码中部分细节

3.1 std::lock_guardstd::mutex lock(mutex_);

std::lock_guardstd::mutex lock(mutex_); 这行代码的含义是创建一个 std::lock_guard 类型的 RAII 对象 lock，该对象被创建时会自动获取 mutex_ 的锁，并在作用域结束时自动释放锁，以保证使用 mutex_ 的代码区域的线程安全性。

std::lock_guard 是 C++11 标准库中定义的一个模板类，用于在构造函数中获取互斥锁，析构函数中释放互斥锁，以便确保在互斥锁的作用域结束时自动释放锁，避免线程锁定问题。

在上述代码中，mutex_ 是一个互斥锁对象，std::lock_guard 模板类的参数类型必须是互斥锁类型，即 std::mutex 类型或其派生类类型。当 lock_guard 对象的作用域结束时，它会自动调用析构函数释放互斥锁，不需要手动调用 unlock() 来释放锁。

因此，std::lock_guardstd::mutex lock(mutex_); 这行代码的作用就是在当前作用域中获取 mutex_ 的锁，并在作用域结束时自动释放锁，以确保使用 mutex_ 的代码区域的线程安全性。

3.2 cv.wait(lock, [] { return ready; }) cv.wait()能传入什么参数？每个参数什么意思

cv.wait(lock, pred) 是条件变量 cv 的一个成员函数，其中 lock 是一个 std::unique_lock 类型的对象，用于锁定互斥锁，pred 是一个可调用对象（比如 lambda 表达式），用于检查是否满足等待条件。如果等待条件不满足，线程将被阻塞，直到接收到条件变量的通知。

具体来说，cv.wait(lock, pred) 的含义如下：

如果 lock 没有锁定互斥锁，则在调用 wait 之前会自动锁定互斥锁，防止其他线程同时修改共享数据。
如果 pred 的返回值为 false，则当前线程将被阻塞，直到接收到条件变量 cv 的通知。在等待期间，互斥锁 lock 会被自动释放，以允许其他线程修改共享数据。
如果 pred 的返回值为 true，则 wait 函数立即返回，当前线程不会被阻塞。此时，互斥锁 lock 仍然被当前线程锁定。

[] { return ready; } 是 C++11 引入的 lambda 表达式语法。它是一个匿名函数对象，可以用于表示一个可调用对象。具体来说，这个 lambda 表达式的含义是返回一个 bool 类型的值，其值等于变量 ready 的值。因为在这里没有传入任何参数，所以这个 lambda 表达式是一个无参数的函数。