在C++多线程编程场景中，类作为封装数据和操作的基本单元，若没有合理的并发控制设计，多个线程同时访问类的实例时就可能出现数据竞争、状态不一致等问题，因此需要在类设计阶段就规划好并发控制策略。
常见的C++并发控制工具
C++标准库提供了一系列并发控制相关的组件，在类设计中可以根据实际需求选择使用：
- 互斥锁（std::mutex）：最基础的同步原语，用于保护共享数据，同一时间只允许一个线程持有锁。
- 锁管理工具（std::lock_guard、std::unique_lock）：RAII风格的锁包装器，避免手动解锁遗漏导致的死锁问题。
- 原子变量（std::atomic）：针对简单数据类型的无锁同步方案，性能优于互斥锁，适合计数器、状态标志等场景。
- 读写锁（std::shared_mutex）：适合读多写少的场景，允许多个线程同时读，写操作独占访问。
基于互斥锁的类设计示例
对于包含多个共享成员变量的类，使用互斥锁保护所有访问路径是最常见的方案。以下是一个简单的计数器类设计：
#include <mutex>
#include <iostream>
class Counter {
private:
int count; // 共享计数变量
std::mutex mtx; // 互斥锁保护count
public:
Counter(int init_val = 0) : count(init_val) {}
// 增加计数
void increment() {
std::lock_guard<std::mutex> lock(mtx); // 自动加锁，作用域结束自动解锁
++count;
}
// 获取当前计数
int get_count() {
std::lock_guard<std::mutex> lock(mtx);
return count;
}
// 重置计数
void reset(int new_val) {
std::lock_guard<std::mutex> lock(mtx);
count = new_val;
}
};
这个设计中所有访问count成员的函数都通过std::lock_guard加锁，确保同一时间只有一个线程能修改或读取count，避免数据竞争。需要注意的是，互斥锁要保护所有访问共享变量的路径，不能遗漏任何一个成员函数。
原子变量的适用场景
如果类中只需要保护单个简单类型的变量，比如标志位、计数器，使用原子变量会比互斥锁更高效，因为原子变量的操作通常是无锁的。以下是使用原子变量实现的计数器类：
#include <atomic>
#include <iostream>
class AtomicCounter {
private:
std::atomic<int> count; // 原子计数变量
public:
AtomicCounter(int init_val = 0) : count(init_val) {}
void increment() {
count.fetch_add(1, std::memory_order_relaxed); // 松散内存序，适合计数场景
}
int get_count() {
return count.load(std::memory_order_relaxed);
}
void reset(int new_val) {
count.store(new_val, std::memory_order_relaxed);
}
};
这里使用std::atomic<int>替代普通int，所有操作都保证原子性，不需要额外的互斥锁。不过原子变量只适合简单数据类型，对于复杂结构体、容器等类型，还是需要使用互斥锁保护。
读写锁的优化方案
当类的操作读多写少时，使用普通互斥锁会导致读操作之间也被串行化，影响性能，此时可以使用读写锁。以下是一个简单的缓存类示例：
#include <shared_mutex>
#include <unordered_map>
#include <string>
class Cache {
private:
std::unordered_map<std::string, std::string> data;
mutable std::shared_mutex rw_mtx; // 读写锁，mutable允许const函数修改
public:
// 读操作，使用共享锁
std::string get(const std::string& key) const {
std::shared_lock<std::shared_mutex> lock(rw_mtx); // 共享锁，多个读线程可同时持有
auto it = data.find(key);
if (it != data.end()) {
return it->second;
}
return "";
}
// 写操作，使用独占锁
void put(const std::string& key, const std::string& value) {
std::unique_lock<std::shared_mutex> lock(rw_mtx); // 独占锁，写操作独占访问
data[key] = value;
}
};
读操作使用std::shared_lock加共享锁，多个线程可以同时读缓存；写操作使用std::unique_lock加独占锁，保证写操作时没有其他线程读或写，兼顾了性能和线程安全。
类设计中的并发控制注意事项
在类设计中处理并发控制时，还需要注意以下几点：
- 避免返回共享变量的引用或指针，否则外部代码可以绕过类的锁直接访问共享数据，破坏线程安全。
- 锁的粒度要合适，不要过大也不要过小，过大影响性能，过小可能导致多个锁之间出现死锁或者保护不完整。
- 如果类的实例会被多个线程共享，要确保类的所有公共接口都做了并发控制，或者明确文档说明类不是线程安全的，需要外部调用者加锁。
- 尽量避免在持有锁的情况下调用外部未知的代码，防止出现死锁或者锁的持有时间过长的问题。
并发控制的核心是在保证线程安全的前提下，尽可能降低性能损耗，类设计阶段就需要结合类的使用场景选择合适的控制方案。
C++并发控制mutexlock_guardatomic线程安全修改时间：2026-06-23 22:54:36