C++ 条件变量,互斥锁

C++ 中多线程编程的两个核心同步原语：互斥锁 (Mutex) 和 条件变量 (Condition Variable)。它们是实现线程间安全通信和协调的关键。

1. 互斥锁 (Mutex)

核心概念

互斥锁用于保护共享数据，确保同一时间只有一个线程可以访问该数据，从而避免数据竞争 (Data Race)。

原理：线程在访问共享数据前先上锁 (lock)，如果锁已被其他线程占用，则当前线程阻塞 (block) 等待。访问完成后解锁 (unlock)，让其他线程有机会获取锁。

C++ 中的互斥锁 (<mutex> 头文件)

1. std::mutex

最基本的互斥锁。

cpp

#include <iostream>
#include <thread>
#include <mutex>std::mutex g_mutex; // 全局互斥锁
int shared_data = 0;void increment() {for (int i = 0; i < 100000; ++i) {g_mutex.lock();    // 上锁++shared_data;     // 临界区代码g_mutex.unlock();  // 解锁}
}int main() {std::thread t1(increment);std::thread t2(increment);t1.join();t2.join();std::cout << "Final value: " << shared_data << std::endl; // 正确输出 200000return 0;
}

2. std::lock_guard (推荐使用)

RAII 风格的锁管理，在构造时自动上锁，析构时自动解锁，即使发生异常也能保证解锁，避免死锁。

cpp

void safe_increment() {for (int i = 0; i < 100000; ++i) {std::lock_guard<std::mutex> lock(g_mutex); // 构造时上锁，析构时解锁++shared_data;} // lock_guard 在此析构，自动解锁
}

3. std::unique_lock (更灵活)

比 lock_guard 更灵活，可以手动控制上锁和解锁的时机，是条件变量必需的伙伴。

cpp

void flexible_increment() {for (int i = 0; i < 100000; ++i) {std::unique_lock<std::mutex> lock(g_mutex); // 自动上锁++shared_data;// 可以手动提前解锁，不需要等到作用域结束lock.unlock();// ... 这里可以执行一些不涉及共享数据的操作}
}

2. 条件变量 (Condition Variable)

核心概念

条件变量用于线程间的通信和协调。它允许一个线程等待某个条件成立，而其他线程在条件成立时通知等待的线程。

典型生产者-消费者模式：

• 消费者线程等待"缓冲区不为空"的条件

• 生产者线程在放入数据后通知消费者

C++ 中的条件变量 (<condition_variable> 头文件)

基本使用模式

cpp

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>std::mutex mtx;
std::condition_variable cv;
std::queue<int> data_queue;
const int MAX_SIZE = 5;// 生产者线程
void producer() {for (int i = 0; i < 10; ++i) {std::unique_lock<std::mutex> lock(mtx);// 等待条件：队列未满// 使用lambda表达式作为等待条件cv.wait(lock, [] { return data_queue.size() < MAX_SIZE; });data_queue.push(i);std::cout << "Produced: " << i << std::endl;lock.unlock(); // 手动解锁（可选，notify之前解锁更好）cv.notify_one(); // 通知一个等待的消费者}
}// 消费者线程
void consumer() {while (true) {std::unique_lock<std::mutex> lock(mtx);// 等待条件：队列不为空cv.wait(lock, [] { return !data_queue.empty(); });int data = data_queue.front();data_queue.pop();std::cout << "Consumed: " << data << std::endl;lock.unlock();cv.notify_one(); // 通知生产者可能有空位了if (data == 9) break; // 收到最后一个数据后退出}
}int main() {std::thread prod(producer);std::thread cons(consumer);prod.join();cons.join();return 0;
}

条件变量的关键方法

1. wait(lock, predicate):

   • 原子地解锁并阻塞当前线程

   • 被唤醒后重新获取锁

   • 检查 predicate 条件，如果为 false 则继续等待

2. notify_one():

   • 唤醒一个等待中的线程（如果有）

3. notify_all():

   • 唤醒所有等待中的线程

3. 为什么条件变量需要互斥锁？

条件变量必须与互斥锁配合使用，原因如下：

1. 原子性操作：检查条件和进入等待必须是原子操作，否则可能发生：

   • 线程A检查条件 → 条件不满足

   • 线程B修改条件并发出通知

   • 线程A才开始等待 → 通知丢失，线程A永远等待

2. 保护共享状态：条件变量等待的"条件"通常是共享数据，需要用互斥锁保护。

4. 完整的生产者-消费者示例

cpp

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>class ThreadSafeQueue {
private:std::queue<int> queue_;std::mutex mtx_;std::condition_variable cv_producer_;std::condition_variable cv_consumer_;const int max_size_ = 5;bool stop_ = false;public:void push(int value) {std::unique_lock<std::mutex> lock(mtx_);cv_producer_.wait(lock, [this] { return queue_.size() < max_size_ || stop_; });if (stop_) return;queue_.push(value);std::cout << "Produced: " << value << std::endl;cv_consumer_.notify_one();}int pop() {std::unique_lock<std::mutex> lock(mtx_);cv_consumer_.wait(lock, [this] { return !queue_.empty() || stop_; });if (stop_ && queue_.empty()) return -1;int value = queue_.front();queue_.pop();std::cout << "Consumed: " << value << std::endl;cv_producer_.notify_one();return value;}void stop() {std::lock_guard<std::mutex> lock(mtx_);stop_ = true;cv_producer_.notify_all();cv_consumer_.notify_all();}
};int main() {ThreadSafeQueue queue;std::thread producer([&queue] {for (int i = 0; i < 10; ++i) {queue.push(i);std::this_thread::sleep_for(std::chrono::milliseconds(100));}queue.stop();});std::thread consumer([&queue] {while (true) {int value = queue.pop();if (value == -1) break;std::this_thread::sleep_for(std::chrono::milliseconds(150));}});producer.join();consumer.join();return 0;
}

5. 重要注意事项和最佳实践

1. 虚假唤醒 (Spurious Wakeup)：线程可能在没有收到通知的情况下被唤醒，因此必须使用谓词检查条件。

2. 优先使用 std::lock_guard 和 std::unique_lock：避免手动调用 lock()/unlock()。

3. 在通知前解锁：在调用 notify_one() 或 notify_all() 前解锁，可以让被唤醒的线程立即获取锁，提高性能。

4. 使用 RAII：确保异常安全，所有资源都能正确释放。

5. 避免嵌套锁：容易导致死锁。

总结对比

掌握互斥锁和条件变量是编写正确、高效多线程 C++ 程序的基础。