C++并发学习二：std::condition_variable 的基本使用

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <string>

class DataProcessor {
public:
    void consumeData() {
        std::cout << "[Consumer] Waiting for data..." << std::endl;
        
        // TODO: 在这里等待条件满足
        // 提示:
        // 1. 需要一个 std::unique_lock
        // 2. 调用 condition_variable 的 wait 方法
        // 3. wait 的第二个参数是一个 lambda，它代表了需要满足的“条件”
        //    (我们的条件是 is_ready_ 变为 true)

        std::unique_lock<std::mutex> lock(mtx_);
        while (!is_ready_) {
            cv_.wait(lock);
        }
        // 更简单的写法：闭包写法
        // 注意这里lambda返回的应该是“等待结束”的条件，也即下面这行代码的意思是：
        // 等待`is_ready_`为`true`后，不再cv_wait()
        // cv_.wait(lock, [&]{ return is_ready_; }); 
        
        std::cout << "[Consumer] Data is ready! Processing: " << data_ << std::endl;

        is_ready_ = false;
    }

    void produceData(const std::string& data) {
        std::cout << "[Producer] Preparing data..." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作

        // TODO: 在这里准备数据并通知消费者
        // 提示:
        // 1. 需要一个 std::lock_guard 或 std::unique_lock
        // 2. 修改共享数据 (data_ 和 is_ready_)
        // 3. 调用 condition_variable 的 notify_one() 方法唤醒消费者
        
        std::unique_lock<std::mutex> lock(mtx_);
        // 生产者同样要等待is_ready_，只不过变为等待它为为false。不等待的话会导致丢数据。
        while (is_ready_) {
            cv_.wait(lock);
        }
        // cv_.wait(lock, [&]{ return !is_ready_; });

        data_ = data;
        is_ready_ = true;

        cv_.notify_one();

        std::cout << "[Producer] Data produced." << std::endl;
    }

private:
    std::string data_;
    bool is_ready_ = false; // 共享的“条件”

    std::mutex mtx_;
    std::condition_variable cv_;
};

int main() {
    DataProcessor processor;

    std::thread consumer_thread(&DataProcessor::consumeData, &processor);
    std::thread producer_thread(&DataProcessor::produceData, &processor, "Hello, C++ Concurrency!");

    consumer_thread.join();
    producer_thread.join();

    return 0;
}