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）保护整个缓存结构。

立即学习“C++免费学习笔记（深入）”；

Unreal Images

免费的AI图片库

下载

示例中使用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();
            }
        }
    }
};

使用建议与优化方向

上述实现适用于大多数并发读写场景。若读多写少，可考虑升级为std::shared_mutex（C++17），允许多个读线程同时访问，写操作仍独占锁。

• 性能考量：频繁加锁可能成为瓶颈，可通过分片缓存（Sharded Cache）降低锁竞争
• 内存管理：避免存储大对象，必要时用智能指针包装
• 无锁尝试：完全无锁LRU极难实现且易出错，不推荐初学者尝试

基本上就这些。核心是理解LRU逻辑，再通过互斥锁保护共享状态，即可构建一个实用的线程安全缓存。