当前位置： 首页 > news >正文

C++ 条件变量,互斥锁

news 2025/9/4 18:36:33

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. 避免嵌套锁：容易导致死锁。

总结对比

特性互斥锁 (Mutex)条件变量 (Condition Variable)
主要目的保护共享数据，避免数据竞争线程间通信和协调
操作lock(), unlock()wait(), notify_one(), notify_all()
配合使用可以单独使用必须与互斥锁配合使用
阻塞原因等待获取锁等待某个条件成立
典型模式临界区保护生产者-消费者

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

http://www.dtcms.com/a/363385.html

相关文章：

  • vue飞自在酒店管理系统（代码+数据库+LW）
  • 第十七讲：编译链接与函数栈帧
  • Python图像处理模块介绍
  • Linux 文本处理四剑客：cut, sort, uniq, tr
  • springboot redisson 分布式锁切面入门与实战
  • HTML应用指南：利用POST请求获取全国便利蜂门店位置信息
  • 面试tips--JVM(4)--Minor GC Major GC Full GC
  • 从理念到实践：三层解耦架构与“无系统”论
  • 59.螺旋矩阵II
  • 科研界“外挂”诞生了：科学多模态模型Intern-S1-mini开源
  • linux开发板(rk3568,树莓派)自动连接保存好的WIFI
  • 百度网盘基于Flink的实时计算实践
  • SpringMVC —— Spring集成web环境和SpringMVC快速入门
  • 微信小程序列表之分页、刷新、加载更多开发
  • [密码学实战]逆向工程常见工具合集及下载地址（四十七）
  • 顶级天才会思考什么问题
  • Unity切换平台资源重新编译缓慢
  • 嵌入式git分支管理策略
  • 江协科技STM32学习笔记补充之002 对比介绍 I²C 和 SPI 两种常见的串行总线接口
  • Linux 环境配置 Boost 库详细步骤
  • C++二维数组的前缀和
  • 高德开放平台智能眼镜解决方案，Rokid Glasses AR导航实测
  • 相较于传统AR矿物鉴定有哪些优势？
  • AR技术赋能风电运维：精准、高效、智能
  • Android 16k页面大小适配
  • 抄苹果作业，安卓「无视风险，继续安装」要被谷歌砍了？
  • ADB图片上传轮播
  • 2022版Unity创建时没有2D灯光（2D Light），没有Global LIght2D怎么办？
  • MYSQL 认识事务
  • Python实现多线程PDF抓取与下载脚本