C++怎么实现一个简单的线程安全哈希表_C++使用分段锁或读写锁优化并发性能_技术教程

线程安全哈希表可通过互斥锁、读写锁或分段锁实现；低并发用mutex，读多写少用shared_mutex，高并发推荐分段锁以降低竞争，提升性能。

实现一个线程安全的哈希表，核心是在并发访问时保护数据不被破坏。C++中可以通过互斥锁（mutex）、读写锁（shared_mutex）或分段锁（striped locking）来控制对桶（bucket）的访问。为了提升性能，避免全局锁成为瓶颈，可以采用分段锁或读写锁机制。

使用标准互斥锁的简单线程安全哈希表

最直接的方式是为整个哈希表加一把互斥锁。虽然实现简单，但在高并发下性能较差，因为所有操作都串行化。

#include 
#include 

template
class ThreadSafeHashMap {
private:
    std::unordered_map map_;
    mutable std::mutex mtx_;

public:
    void put(const K& key, const V& value) {
        std::lock_guard lock(mtx_);
        map_[key] = value;
    }

    V get(const K& key) const {
        std::lock_guard lock(mtx_);
        auto it = map_.find(key);
        return it != map_.end() ? it->second : V{};
    }

    bool remove(const K& key) {
        std::lock_guard lock(mtx_);
        return map_.erase(key) > 0;
    }
};

这个版本适合低并发场景。但当读多写少时，每次读操作也需独占锁，效率低下。

使用读写锁提升读性能

在读操作远多于写操作的场景下，使用 std::shared_mutex（C++17 起支持）能显著提升性能。读操作共享锁，写操作独占锁。

#include 
#include 

template
class ThreadSafeHashMapRW {
private:
    std::unordered_map map_;
    mutable std::shared_mutex rw_mutex_;

public:
    void put(const K& key, const V& value) {
        std::unique_lock lock(rw_mutex_);
        map_[key] = value;
    }

    V get(const K& key) const {
        std::shared_lock lock(rw_mutex_);
        auto it = map_.find(key);
        return it != map_.end() ? it->second : V{};
    }

    bool remove(const K& key) {
        std::unique_lock lock(rw_mutex_);
        return map_.erase(key) > 0;
    }
};

多个线程可同时进行 get 操作，只有 put 和 remove 会阻塞彼此和其他操作。适用于缓存、配置中心等读密集型应用。

使用分段锁减少锁竞争

进一步优化，可以将哈希表分成多个段（segment），每段有自己的锁。这样不同段的操作可以并发执行，降低锁争用。

常见做法是创建一个固定大小的锁数组，通过哈希值映射到某个锁。

#include 
#include 
#include 
#include 
#include 

template
class StripedHashMap {
private:
    std::vector> buckets_;
    std::vector locks_;

    size_t hash_to_segment(const K& key) const {
        return std::hash{}(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 lock(locks_[seg]);
        buckets_[seg][key] = value;
    }

    V get(const K& key) const {
        size_t seg = hash_to_segment(key);
        std::shared_lock 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 lock(locks_[seg]);
        return buckets_[seg].erase(key) > 0;
    }
};

这种设计将锁的粒度从整个表缩小到每个桶，显著提升并发吞吐量。N 通常取 16 或 32，需根据实际并发量调整。