c++怎么实现一个线程安全的LRU缓存_C++并发编程中的缓存设计与实现_技术教程

答案：基于哈希表和双向链表实现线程安全的LRU缓存，使用std::mutex保证get和put操作的原子性，通过splice维护访问顺序，并在超出容量时淘汰尾部元素。

实现一个线程安全的LRU（Least Recently Used）缓存是C++并发编程中常见的需求，尤其在高并发服务场景下，如数据库连接池、HTTP响应缓存等。关键在于保证缓存操作（get、put）的原子性，并兼顾性能与正确性。

基本LRU结构设计

标准LRU通常结合哈希表和双向链表：

哈希表（unordered_map）：快速定位缓存节点，O(1)查找
双向链表（list或自定义）：维护访问顺序，最近使用的放头部，淘汰尾部元素

每次get或put操作后，对应节点需移动到链表头部表示“最近使用”。

线程安全的关键：锁策略

为避免数据竞争，必须对共享数据加锁。常见做法是使用互斥锁（mutex）保护整个缓存结构。

注意：细粒度锁虽然能提升并发性能，但会显著增加复杂度，一般推荐使用单个mutex配合条件变量（如需要阻塞等待空间）。

示例中使用std::mutex和std::lock_guard确保操作的原子性。

C++实现示例

以下是一个简洁、线程安全的LRU缓存实现：

#include 
#include 
#include 

template
class ThreadSafeLRUCache {
private:
    size_t capacity;
    std::unordered_map>::iterator> cache_map;
    std::list> cache_list;
    mutable std::mutex mtx;

public:
    explicit ThreadSafeLRUCache(size_t cap) : capacity(cap) {}

    bool get(const K& key, V& value) {
        std::lock_guard lock(mtx);
        auto it = cache_map.find(key);
        if (it == cache_map.end()) {
            return false; // 未命中
        }
        // 将命中节点移到链表头部
        cache_list.splice(cache_list.begin(), cache_list, it->second);
        value = it->second->second;
        return true;
    }

    void put(const K& key, const V& value) {
        std::lock_guard lock(mtx);
        auto it = cache_map.find(key);
        if (it != cache_map.end()) {
            // 更新值并移至头部
            it->second->second = value;
            cache_list.splice(cache_list.begin(), cache_list, it->second);
        } else {
            // 插入新元素
            cache_list.emplace_front(key, value);
            cache_map[key] = cache_list.begin();
            // 超出容量时淘汰尾部
            if (cache_map.size() > capacity) {
                auto last = cache_list.back();
                cache_map.erase(last.first);
                cache_list.pop_back();
            }
        }
    }
};