在C++并发编程中，多个线程同时读写同一个数据结构时，如果没有合理的同步机制，很容易出现数据竞争、结果不符合预期甚至程序崩溃的问题。设计线程安全的并发数据结构，需要充分考虑多线程的访问特性，平衡安全性和性能。
线程安全设计的核心原则
首先需要明确线程安全的基本目标：多个线程并发访问数据结构时，不管调度顺序如何，都能得到正确的结果，且不会出现未定义行为。设计时需要遵循几个核心原则：
- 最小权限原则：只保护需要同步的共享数据，避免不必要的锁范围扩大，减少性能损耗。
- 避免死锁：如果多个数据结构需要同时加锁，要统一加锁的顺序，或者使用
std::scoped_lock这样的工具自动管理锁的获取。 - 保证操作的原子性：单个公开接口的操作要么全部完成，要么全部不生效，不能被其他线程打断。
基于互斥锁的线程安全数据结构实现
互斥锁是最常用的线程同步工具，适合大多数需要保护共享数据的场景。以线程安全的栈为例，我们可以将底层容器和互斥锁封装在一起，所有公开接口都先获取锁再操作。
#include <stack>
#include <mutex>
#include <memory>
template<typename T>
class ThreadSafeStack {
private:
std::stack<T> data;
mutable std::mutex mtx;
public:
// 入栈操作，加锁保护
void push(const T& value) {
std::lock_guard<std::mutex> lock(mtx);
data.push(value);
}
// 出栈并返回值，加锁保护
std::shared_ptr<T> pop() {
std::lock_guard<std::mutex> lock(mtx);
if (data.empty()) {
return nullptr;
}
std::shared_ptr<T> res = std::make_shared<T>(data.top());
data.pop();
return res;
}
// 判断栈是否为空，加锁保护
bool empty() const {
std::lock_guard<std::mutex> lock(mtx);
return data.empty();
}
};上面的实现中，所有修改或者读取栈内部状态的操作都先获取互斥锁，保证同一时间只有一个线程能操作栈的数据，避免了数据竞争。需要注意的是，empty()方法被声明为const，对应的互斥锁也需要声明为mutable，才能在const成员函数中加锁。
读写场景下的锁优化
如果数据结构的读操作远多于写操作，使用普通的互斥锁会导致所有读操作也串行执行，性能浪费较大。这时候可以使用读写锁std::shared_mutex，读操作加共享锁，写操作加独占锁，多个读线程可以同时访问，写线程执行时独占资源。
以线程安全的哈希表为例，读操作只需要加共享锁，写操作加独占锁：
#include <unordered_map>
#include <shared_mutex>
#include <string>
class ThreadSafeHashTable {
private:
std::unordered_map<std::string, int> data;
mutable std::shared_mutex rw_mtx;
public:
// 读操作，加共享锁
int 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 -1; // 不存在返回-1
}
// 写操作，加独占锁
void set(const std::string& key, int value) {
std::unique_lock<std::shared_mutex> lock(rw_mtx);
data[key] = value;
}
// 删除操作，加独占锁
void remove(const std::string& key) {
std::unique_lock<std::shared_mutex> lock(rw_mtx);
data.erase(key);
}
};无锁并发数据结构的设计思路
互斥锁虽然能解决线程安全问题，但会带来上下文切换的开销，且可能出现死锁。如果场景对性能要求极高，可以尝试无锁设计，依赖原子操作和内存序来保证线程安全。无锁设计通常使用std::atomic模板来操作数据，通过CAS（比较并交换）操作实现无锁的更新。
以下是一个简单的无锁栈的简化实现示例，使用原子指针管理栈顶：
#include <atomic>
#include <memory>
template<typename T>
class LockFreeStack {
private:
struct Node {
T data;
Node* next;
Node(const T& val) : data(val), next(nullptr) {}
};
std::atomic<Node*> head;
public:
LockFreeStack() : head(nullptr) {}
// 入栈，无锁CAS操作
void push(const T& value) {
Node* new_node = new Node(value);
new_node->next = head.load(std::memory_order_relaxed);
// 循环尝试更新栈顶，直到成功
while (!head.compare_exchange_weak(
new_node->next,
new_node,
std::memory_order_release,
std::memory_order_relaxed
));
}
// 出栈，无锁CAS操作
std::shared_ptr<T> pop() {
Node* old_head = head.load(std::memory_order_relaxed);
// 循环尝试更新栈顶，直到成功或者栈为空
while (old_head && !head.compare_exchange_weak(
old_head,
old_head->next,
std::memory_order_release,
std::memory_order_relaxed
));
if (old_head) {
std::shared_ptr<T> res = std::make_shared<T>(old_head->data);
delete old_head;
return res;
}
return nullptr;
}
};无锁设计的核心是正确处理内存序，避免指令重排带来的问题，同时要注意ABA问题，必要时可以使用带版本号的原子指针或者风险指针来解决。
设计时的常见注意事项
无论使用哪种方式设计并发数据结构，都要注意几个常见问题：不要在持有锁的情况下调用用户传入的回调，避免回调里再获取其他锁导致死锁；尽量避免返回内部数据的引用，防止锁释放后其他线程修改数据导致悬垂引用；如果需要同时操作多个数据结构，要统一加锁顺序，或者使用std::scoped_lock一次性获取多个锁，避免死锁。