C++如何实现简单的线程安全LRU缓存-C++-PHP中文网

直接用 std::unordered_map + std::list 实现 LRU 缓存线程不安全，因其非线程安全且 get() 需修改 list 顺序，所有操作必须由同一 mutex 保护，避免迭代器失效、崩溃或状态不一致。

c++如何实现简单的线程安全lru缓存

为什么直接用 `std::unordered_map` + `std::list` 会线程不安全

因为 std::unordered_map 和 std::list 本身不是线程安全容器，多个线程同时调用 get() 和 put() 时，可能触发迭代器失效、节点重复插入、或链表指针错乱。典型现象是程序随机崩溃、Segmentation fault，或缓存命中率异常归零。

关键点在于：哪怕只读操作（如 get()）也要更新访问顺序——这必须修改链表结构，因此不能简单加个 const 就认为“只读”；所有涉及 map 查找+插入+删除、以及 list 的 splice() 或 erase()，都必须受同一把锁保护。

不要为 get() 和 put() 分别加不同互斥锁——容易引发死锁或状态不一致
避免在锁内做耗时操作（如深拷贝大对象），否则吞吐量骤降
std::shared_mutex 在这里没用：因为 get() 不是纯读，它要改顺序，所以写锁不可避免

用 `std::mutex` 包裹整个操作是最稳妥的起点

对绝大多数中小规模服务（QPS std::mutex 足够，且代码清晰、不易出错。重点是把所有共享状态的访问都包进去：map 查找、list 重排序、容量检查与淘汰。

class LRUCache {
    std::unordered_map<int std::list int>>::iterator> cache_;
    std::list<:pair int>> order_;
    int capacity_;
    mutable std::mutex mtx_;

public:
    LRUCache(int capacity) : capacity_(capacity) {}

    int get(int key) {
        std::lock_guard<:mutex> lock(mtx_);
        auto it = cache_.find(key);
        if (it == cache_.end()) return -1;
        // 把对应节点移到 list 前端
        order_.splice(order_.begin(), order_, it->second);
        return it->second->second;
    }

    void put(int key, int value) {
        std::lock_guard<:mutex> lock(mtx_);
        auto it = cache_.find(key);
        if (it != cache_.end()) {
            it->second->second = value;
            order_.splice(order_.begin(), order_, it->second);
        } else {
            if (cache_.size() >= static_cast<size_t>(capacity_)) {
                // 淘汰尾部
                auto last = order_.back();
                cache_.erase(last.first);
                order_.pop_back();
            }
            order_.emplace_front(key, value);
            cache_[key] = order_.begin();
        }
    }
};</size_t></:mutex></:mutex></:pair></int>