C++ 互斥锁、读写锁、原子操作、条件变量

前言：在多线程的实现中，对临界资源的访问容易产生冲突与竞争。C++提供了一些方法来解决这种资源冲突，如，互斥锁、读写锁、原子操作、条件变量。本文将对这四种方式进行一一介绍。

目录

一、互斥锁（std::mutex）

1.1 原理

1.2 C++库

1.3 代码示例

1.4 注意事项

二、读写锁（std::shared_mutex）

2.1 原理

2.2 C++库

2.3 代码示例

三、原子操作（std::atomic）

3.1 原理

3.2 C++库

3.3 代码示例

3.4 注意事项

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

4.1 原理

4.2 C++库

4.3 代码示例

4.4 注意事项

一、互斥锁（std::mutex）

1.1 原理

互斥锁是最基础的排他性同步语言，其核心逻辑是：同一时刻仅允许一个线程持有锁，其他线程尝试加锁时会阻塞或失败。

1.2 C++库

1.3 代码示例

#include <iostream> #include <mutex> #include <thread> #include <vector> std::mutex mtx; int counter = 0; // 共享资源 // 临界区操作：自增计数器 void increment(int n) { for (int i = 0; i < n; ++i) { // 推荐RAII：lock_guard（作用域结束自动解锁，避免死锁） std::lock_guard<std::mutex> lock(mtx); counter++; // 临界区（独占访问） } } int main() { std::vector<std::thread> threads; for (int i = 0; i < 4; ++i) { threads.emplace_back(increment, 100000); } for (auto& t : threads) t.join(); std::cout << "最终计数器：" << counter << std::endl; // 预期400000 return 0; }

1.4 注意事项

避免死锁，遵循“加锁顺序一致、避免嵌套锁”。

二、读写锁（std::shared_mutex）

2.1 原理

读写锁是互斥锁的优化版，核心思想是：读共享，写排他。即，多个线程可同时持有读锁，但写锁阻塞所有读锁，写操作独占。适合“读多写少”的情况（如缓存配置、日志查询）。

2.2 C++库

C++17引入std::shared_mutex。

2.3 代码示例

#include <iostream> #include <shared_mutex> #include <thread> #include <vector> std::shared_mutex rw_mtx; int cache_data = 0; // 读多写少的共享缓存 // 读线程：共享读锁（多线程同时读） void read_cache(int id) { std::shared_lock<std::shared_mutex> lock(rw_mtx); // 加读锁 std::cout << "读线程" << id << "读取：" << cache_data << std::endl; } // 写线程：排他写锁（独占） void update_cache(int val) { std::lock_guard<std::shared_mutex> lock(rw_mtx); // 加写锁 cache_data = val; std::cout << "写线程更新为：" << val << std::endl; } int main() { std::vector<std::thread> threads; // 5个读线程（同时执行） for (int i = 0; i < 5; ++i) threads.emplace_back(read_cache, i); // 1个写线程（阻塞所有读线程） threads.emplace_back(update_cache, 100); for (auto& t : threads) { t.join(); } return 0; }

三、原子操作（std::atomic）

3.1 原理

原子操作是无锁同步，其原理是：通过CPU指令级原子性（如lock前缀）实现，无需内核调度，适用于简单变量的“读 - 改 - 写”（如计数器、标志位等）。

3.2 C++库

C++11引入std::atomic模板，支持基本数据类型，方法调用包括：

3.3 代码示例

#include <iostream> #include <atomic> #include <thread> #include <vector> std::atomic<int> atomic_counter(0); // 原子计数器 void atomic_increment(int n) { for (int i = 0; i < n; ++i) { atomic_counter++; // 原子自增（无锁） // 等价于：atomic_counter.fetch_add(1, std::memory_order_relaxed); } } // 高级：CAS实现无锁更新 void cas_demo() { int expected = 0; int new_val = 100; // 弱CAS（可能虚假失败，需循环） while (!atomic_counter.compare_exchange_weak(expected, new_val)) { std::cout << "CAS失败，当前值：" << expected << std::endl; } std::cout << "CAS成功，值：" << atomic_counter << std::endl; } int main() { std::vector<std::thread> threads; for (int i = 0; i < 4; ++i) threads.emplace_back(atomic_increment, 100000); for (auto& t : threads) t.join(); std::cout << "原子计数器：" << atomic_counter << std::endl; // 400000 cas_demo(); return 0; }

3.4 注意事项

仅适合简单变量操作，复杂逻辑仍需要加锁。

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

4.1 原理

条件变量解决线程间时序依赖（生产者生产后消费者才能消费），其核心逻辑是：线程A（等待方）阻塞等待条件满足，释放持有的互斥锁，线程B（通知方）满足条件后唤醒等待线程，重新竞争互斥锁。必须与互斥锁配合使用。

4.2 C++库

C++11提供std::consition_variable（仅配合std::unique_lock）与std::condition_variable_any（配合任意类型锁）。

4.3 代码示例

#include <iostream> #include <condition_variable> #include <mutex> #include <thread> #include <queue> std::mutex mtx; std::condition_variable cv; std::queue<int> q; // 共享队列（临界资源） // 生产者：生产数据，通知消费者 void producer(int n) { for (int i = 0; i < n; ++i) { std::unique_lock<std::mutex> lock(mtx); // 加锁 q.push(i); // 生产数据 std::cout << "生产者生产：" << i << std::endl; lock.unlock(); // 可选：提前解锁，减少消费者等待 cv.notify_one(); // 唤醒一个等待的消费者 std::this_thread::sleep_for(std::chrono::milliseconds(100)); } } // 消费者：等待数据，消费 void consumer() { while (true) { std::unique_lock<std::mutex> lock(mtx); // 循环等待：防止虚假唤醒 cv.wait(lock, []() { return !q.empty(); }); // 条件满足，消费数据 int val = q.front(); q.pop(); std::cout << "消费者消费：" << val << std::endl; lock.unlock(); if (val == 9) break; // 消费完退出 } } int main() { std::thread prod(producer, 10); std::thread cons(consumer); prod.join(); cons.join(); return 0; }

4.4 注意事项

std::condition_variable仅支持std::unique_lock，需要手动控制锁的释放。