采用分段锁和读写锁可有效提升C++线程安全哈希表的并发性能，普通场景建议使用分段锁结合std::shared_mutex优化读操作，高性能需求可选用Intel TBB等成熟库。
在C++多线程环境下实现一个线程安全的哈希表，关键在于保证对共享数据的并发访问是同步的，避免数据竞争和不一致状态。直接使用标准容器如std::unordered_map在多线程中读写是不安全的，必须引入同步机制或采用更高级的设计策略。
使用互斥锁保护哈希表操作
最简单的方式是为整个哈希表加一把互斥锁（std::mutex），确保每次只有一个线程能执行插入、删除或查找操作。
#include <unordered_map>
#include <mutex>
template<typename K, typename V>
class ThreadSafeHashMap {
private:
std::unordered_map<K, V> map_;
mutable std::mutex mutex_;
public:
void put(const K& key, const V& value) {
std::lock_guard<std::mutex> lock(mutex_);
map_[key] = value;
}
bool get(const K& key, V& value) const {
std::lock_guard<std::mutex> lock(mutex_);
auto it = map_.find(key);
if (it != map_.end()) {
value = it->second;
return true;
}
return false;
}
bool remove(const K& key) {
std::lock_guard<std::mutex> lock(mutex_);
return map_.erase(key) > 0;
}
};
这种方法实现简单，但性能较差，因为所有操作都串行化了，高并发下容易成为瓶颈。
分段锁（Striped Locking）提升并发性能
为了减少锁的竞争，可以将哈希表分成多个桶段（segment），每个段有自己的锁。线程根据键的哈希值决定使用哪个锁，从而允许多个线程在不同段上并行操作。
立即学习“C++免费学习笔记（深入）”；
这种设计借鉴了Java中ConcurrentHashMap的思想。
- 维护一个固定数量的桶和对应的一组互斥锁。
- 通过哈希值映射到某个桶和锁。
- 每个桶可以是一个
std::unordered_map或链表结构。
template<typename K, typename V>
class ConcurrentHashMap {
private:
static const size_t NUM_BUCKETS = 16;
std::vector<std::unordered_map<K, V>> buckets_;
mutable std::vector<std::mutex> locks_;
size_t hash_to_bucket(const K& key) const {
return std::hash<K>{}(key) % NUM_BUCKETS;
}
public:
ConcurrentHashMap() : buckets_(NUM_BUCKETS), locks_(NUM_BUCKETS) {}
void put(const K& key, const V& value) {
size_t bucket = hash_to_bucket(key);
std::lock_guard<std::mutex> lock(locks_[bucket]);
buckets_[bucket][key] = value;
}
bool get(const K& key, V& value) const {
size_t bucket = hash_to_bucket(key);
std::lock_guard<std::mutex> lock(locks_[bucket]);
const auto& bucket_map = buckets_[bucket];
auto it = bucket_map.find(key);
if (it != bucket_map.end()) {
value = it->second;
return true;
}
return false;
}
};
分段锁显著提升了并发吞吐量，尤其在读多写少场景下表现良好。
读写锁优化读密集场景
如果应用中读操作远多于写操作，可以用std::shared_mutex（C++17起支持）来允许同时多个读线程访问，而写操作仍独占。
将上述分段锁中的std::mutex替换为std::shared_mutex，读用std::shared_lock，写用std::unique_lock。
bool get(const K& key, V& value) const {
size_t bucket = hash_to_bucket(key);
std::shared_lock<std::shared_mutex> lock(locks_[bucket]); // 共享锁
const auto& bucket_map = buckets_[bucket];
auto it = bucket_map.find(key);
if (it != bucket_map.end()) {
value = it->second;
return true;
}
return false;
}
这样多个线程可同时读同一段数据，进一步提升性能。
无锁哈希表（Lock-Free）的可行性
真正高性能的并发哈希表可能需要无锁设计，依赖原子操作和CAS（Compare-And-Swap）。但这非常复杂，涉及内存模型、ABA问题、动态扩容等难题，一般只在极端性能要求场景使用。
C++标准库目前没有提供无锁容器，第三方库如Intel TBB提供了concurrent_hash_map，基于细粒度锁和高效设计，适合生产环境。
自行实现无锁哈希表成本高，建议优先考虑分段锁或成熟库。
基本上就这些。选择哪种方式取决于你的性能需求和使用场景。普通并发用分段锁+读写锁已经足够，追求极致性能再考虑无锁或第三方方案。
