线程安全哈希表可通过互斥锁、读写锁或分段锁实现；低并发用mutex，读多写少用shared_mutex，高并发推荐分段锁以降低竞争，提升性能。
实现一个线程安全的哈希表，核心是在并发访问时保护数据不被破坏。C++中可以通过互斥锁（mutex）、读写锁（shared_mutex）或分段锁（striped locking）来控制对桶（bucket）的访问。为了提升性能，避免全局锁成为瓶颈，可以采用分段锁或读写锁机制。
使用标准互斥锁的简单线程安全哈希表
最直接的方式是为整个哈希表加一把互斥锁。虽然实现简单，但在高并发下性能较差，因为所有操作都串行化。
#include <unordered_map>
#include <mutex>
template<typename K, typename V>
class ThreadSafeHashMap {
private:
std::unordered_map<K, V> map_;
mutable std::mutex mtx_;
public:
void put(const K& key, const V& value) {
std::lock_guard<std::mutex> lock(mtx_);
map_[key] = value;
}
V get(const K& key) const {
std::lock_guard<std::mutex> lock(mtx_);
auto it = map_.find(key);
return it != map_.end() ? it->second : V{};
}
bool remove(const K& key) {
std::lock_guard<std::mutex> lock(mtx_);
return map_.erase(key) > 0;
}
};
这个版本适合低并发场景。但当读多写少时，每次读操作也需独占锁，效率低下。
使用读写锁提升读性能
在读操作远多于写操作的场景下，使用 std::shared_mutex（C++17 起支持）能显著提升性能。读操作共享锁，写操作独占锁。
立即学习“C++免费学习笔记（深入）”；
#include <unordered_map>
#include <shared_mutex>
template<typename K, typename V>
class ThreadSafeHashMapRW {
private:
std::unordered_map<K, V> map_;
mutable std::shared_mutex rw_mutex_;
public:
void put(const K& key, const V& value) {
std::unique_lock<std::shared_mutex> lock(rw_mutex_);
map_[key] = value;
}
V get(const K& key) const {
std::shared_lock<std::shared_mutex> lock(rw_mutex_);
auto it = map_.find(key);
return it != map_.end() ? it->second : V{};
}
bool remove(const K& key) {
std::unique_lock<std::shared_mutex> lock(rw_mutex_);
return map_.erase(key) > 0;
}
};
多个线程可同时进行 get 操作，只有 put 和 remove 会阻塞彼此和其他操作。适用于缓存、配置中心等读密集型应用。
使用分段锁减少锁竞争
进一步优化，可以将哈希表分成多个段（segment），每段有自己的锁。这样不同段的操作可以并发执行，降低锁争用。
常见做法是创建一个固定大小的锁数组，通过哈希值映射到某个锁。
#include <vector>
#include <unordered_map>
#include <mutex>
#include <shared_mutex>
#include <functional>
template<typename K, typename V, size_t N = 16>
class StripedHashMap {
private:
std::vector<std::unordered_map<K, V>> buckets_;
std::vector<std::shared_mutex> locks_;
size_t hash_to_segment(const K& key) const {
return std::hash<K>{}(key) % N;
}
public:
StripedHashMap() : buckets_(N), locks_(N) {}
void put(const K& key, const V& value) {
size_t seg = hash_to_segment(key);
std::unique_lock<std::shared_mutex> lock(locks_[seg]);
buckets_[seg][key] = value;
}
V get(const K& key) const {
size_t seg = hash_to_segment(key);
std::shared_lock<std::shared_mutex> lock(locks_[seg]);
auto it = buckets_[seg].find(key);
return it != buckets_[seg].end() ? it->second : V{};
}
bool remove(const K& key) {
size_t seg = hash_to_segment(key);
std::unique_lock<std::shared_mutex> lock(locks_[seg]);
return buckets_[seg].erase(key) > 0;
}
};
这种设计将锁的粒度从整个表缩小到每个桶，显著提升并发吞吐量。N 通常取 16 或 32，需根据实际并发量调整。
总结与建议
线程安全哈希表的实现应根据使用场景选择合适的同步策略：
- 低并发或简单场景：使用单个 mutex 即可。
- 读多写少：优先使用 shared_mutex，提高读并发。
- 高并发写操作：采用分段锁，分散锁竞争。
注意异常安全和拷贝语义。get 返回值时若键不存在，应明确处理（抛异常或返回 optional）。更健壮的实现可返回 std::optional<V> 而非默认构造值。
基本上就这些。合理选择锁策略，能在保证线程安全的同时获得不错的性能表现。
