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

#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;
    }
};

#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;
    }
};

#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;
    }
};