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

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

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

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