在C++并发编程中，同步机制是保证数据一致性与线程安全的重要工具。std::mutex（互斥锁）提供了基本的互斥访问保护，而std::condition_variable（条件变量）则用于线程间的精确协调，让线程在满足特定条件时才继续执行。本文将深入浅出地讲解这两者的使用、常见问题、易错点以及如何避免这些问题，并通过实例代码加深理解。

C++一分钟之-互斥锁与条件变量_C++

一、互斥锁（std::mutex）

互斥锁是实现线程间资源独占访问的基础手段。一旦一个线程获得了锁，其他试图获取同一锁的线程将会被阻塞，直到锁被释放。

基本用法

std::mutex mtx;
// 加锁
mtx.lock();
// 执行临界区代码
// ...
// 解锁
mtx.unlock();
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.

易错点与避免策略

  1. 忘记解锁：使用std::lock_guard或std::unique_lock自动管理锁的生命周期，确保即使发生异常也能解锁。
  2. 死锁：避免在持有锁的情况下调用可能阻塞的函数，或按相同的顺序获取多个锁。

二、条件变量（std::condition_variable）

条件变量用于线程间同步，允许一个线程等待（挂起）直到另一个线程通知某个条件为真。

基本用法

std::condition_variable cv;
std::mutex mtx;

void waitingFunction() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{return conditionToWaitFor;}); // 条件满足前挂起
    // 条件满足后执行的代码
}

void notifyingFunction() {
    // 修改状态使得conditionToWaitFor为真
    std::lock_guard<std::mutex> lock(mtx);
    cv.notify_one(); // 唤醒一个等待的线程
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.

常见问题与避免策略

  1. 无条件唤醒：不要在没有改变条件的情况下调用notify_*函数，这可能导致不必要的线程唤醒和重新检查条件。
  2. 虚假唤醒：即使没有调用notify_*，等待的线程也可能被唤醒。因此，总是使用条件来检查是否真正满足继续执行的条件。
  3. 死锁：确保在调用wait之前已经获得了锁，并且在wait之后立即检查条件，避免在持有锁的情况下执行耗时操作。

三、综合示例：生产者-消费者模型

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

std::queue<int> producedItems;
std::mutex mtx;
std::condition_variable condVar;

bool doneProducing = false;

void producer(int n) {
    for (int i = 0; i < n; ++i) {
        std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟生产时间
        std::lock_guard<std::mutex> lock(mtx);
        producedItems.push(i);
        condVar.notify_one(); // 通知消费者
        if (i == n - 1) doneProducing = true;
    }
}

void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        condVar.wait(lock, []{return !producedItems.empty() || doneProducing;});
        if (!producedItems.empty()) {
            int item = producedItems.front();
            producedItems.pop();
            std::cout << "Consumed: " << item << std::endl;
        } else if (doneProducing) {
            break;
        }
    }
}

int main() {
    std::thread producerThread(producer, 10);
    std::thread consumerThread(consumer);

    producerThread.join();
    consumerThread.join();

    return 0;
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.

四、总结

互斥锁和条件变量是构建复杂并发系统不可或缺的组件。正确使用它们，可以有效解决线程间的同步问题，避免数据竞争和死锁。实践中，应注重细节，如使用RAII模式管理锁的生命周期、仔细设计条件判断逻辑，以及避免无意义的线程唤醒。通过上述示例和策略的学习，希望你能更加自信地在C++项目中应用这些并发工具，提升程序的并发性能和可靠性。随着经验的积累，逐步探索更高级的并发模式和库，如C++20中的std::latch和std::barrier，将使你的并发编程技能更加全面和高效。