前言你有没有想过Redis的内存淘汰策略、MySQL的缓冲池、浏览器的后退按钮背后都用到了同一个算法LRULeast Recently Used最近最少使用。今天我们手写一个生产级的LRU缓存· O(1)时间复杂度的get和put· 支持泛型存储· 线程安全· 过期时间支持· 缓存统计---一、LRU的核心原理1. 淘汰策略当缓存满了要淘汰谁访问顺序A → B → C → D → E刚访问了E如果满了需要淘汰1个- FIFO先进先出淘汰A- LFU最不经常使用淘汰B假设B访问次数最少- LRU最近最少使用淘汰AA最久没被访问2. 数据结构选择LRU需要两个操作都是O(1)· 快速查找哈希表 O(1)· 维护访问顺序双向链表 O(1)┌─────────────────────────────────────────────────┐│ 哈希表 ││ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ││ │key1 │ │key2 │ │key3 │ │key4 │ │key5 │ ││ └──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘ ││ │ │ │ │ │ │└─────┼───────┼───────┼───────┼───────┼─────────┘│ │ │ │ │▼ ▼ ▼ ▼ ▼┌─────────────────────────────────────────────────┐│ 双向链表 ││ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ││ │ Node │◄──►│ Node │◄──►│ Node │◄──►│ Node │ ││ │head │ │ │ │ │ │tail │ ││ └─────┘ └─────┘ └─────┘ └─────┘ ││ ↑ ↑ ││ 最久未使用 最近使用 │└─────────────────────────────────────────────────┘操作流程· get(key)哈希表找到节点 → 移动到链表头部 → 返回值· put(key, value)存在则更新并移到头不存在则创建插入头部满了则删除尾部---二、完整代码实现1. 双向链表节点定义c#include stdio.h#include stdlib.h#include string.h#include pthread.h#include time.h// 链表节点typedef struct lru_node {char *key; // 键void *value; // 值time_t expire_time; // 过期时间0表示永不过期struct lru_node *prev; // 前驱指针struct lru_node *next; // 后继指针} lru_node_t;// LRU缓存结构typedef struct {lru_node_t **hash_table; // 哈希表拉链法int hash_size; // 哈希表大小lru_node_t *head; // 链表头最近使用lru_node_t *tail; // 链表尾最久未使用int capacity; // 容量int count; // 当前数量pthread_mutex_t mutex; // 互斥锁// 统计信息long long hits; // 命中次数long long misses; // 未命中次数} lru_cache_t;2. 哈希函数c// 简单高效的哈希函数unsigned int lru_hash(const char *str, int table_size) {unsigned int hash 5381;int c;while ((c *str)) {hash ((hash 5) hash) c;}return hash % table_size;}3. 创建和销毁缓存c// 创建LRU缓存lru_cache_t *lru_cache_create(int capacity, int hash_size) {lru_cache_t *cache malloc(sizeof(lru_cache_t));if (!cache) return NULL;cache-hash_size hash_size;cache-hash_table calloc(hash_size, sizeof(lru_node_t*));if (!cache-hash_table) {free(cache);return NULL;}cache-head NULL;cache-tail NULL;cache-capacity capacity;cache-count 0;cache-hits 0;cache-misses 0;pthread_mutex_init(cache-mutex, NULL);return cache;}// 释放链表中的节点void free_node(lru_node_t *node) {if (!node) return;free(node-key);free(node-value);free(node);}// 销毁整个缓存void lru_cache_destroy(lru_cache_t *cache) {if (!cache) return;pthread_mutex_lock(cache-mutex);// 释放所有节点lru_node_t *node cache-head;while (node) {lru_node_t *next node-next;free_node(node);node next;}free(cache-hash_table);pthread_mutex_unlock(cache-mutex);pthread_mutex_destroy(cache-mutex);free(cache);}4. 链表操作c// 从链表中移除节点void remove_node(lru_cache_t *cache, lru_node_t *node) {if (node-prev) {node-prev-next node-next;} else {cache-head node-next; // 是头节点}if (node-next) {node-next-prev node-prev;} else {cache-tail node-prev; // 是尾节点}node-prev NULL;node-next NULL;}// 将节点移动到链表头部最近使用void move_to_head(lru_cache_t *cache, lru_node_t *node) {if (cache-head node) return; // 已经在头部// 先从原位置移除remove_node(cache, node);// 插入到头部node-next cache-head;node-prev NULL;if (cache-head) {cache-head-prev node;}cache-head node;if (!cache-tail) {cache-tail node;}}// 删除尾部节点最久未使用lru_node_t* pop_tail(lru_cache_t *cache) {if (!cache-tail) return NULL;lru_node_t *tail cache-tail;remove_node(cache, tail);return tail;}5. 哈希表操作c// 添加或更新哈希表项void hash_table_put(lru_cache_t *cache, const char *key, lru_node_t *node) {unsigned int index lru_hash(key, cache-hash_size);// 检查是否已存在相同key的节点更新时使用lru_node_t **curr cache-hash_table[index];while (*curr) {if (strcmp((*curr)-key, key) 0) {// 替换旧节点*curr node;return;}curr ((*curr)-next);}// 插入新节点头插法node-next cache-hash_table[index];cache-hash_table[index] node;}// 从哈希表中获取节点lru_node_t* hash_table_get(lru_cache_t *cache, const char *key) {unsigned int index lru_hash(key, cache-hash_size);lru_node_t *node cache-hash_table[index];while (node) {if (strcmp(node-key, key) 0) {return node;}node node-next;}return NULL;}// 从哈希表中删除节点void hash_table_remove(lru_cache_t *cache, const char *key) {unsigned int index lru_hash(key, cache-hash_size);lru_node_t **curr cache-hash_table[index];while (*curr) {if (strcmp((*curr)-key, key) 0) {lru_node_t *to_remove *curr;*curr to_remove-next;return;}curr ((*curr)-next);}}6. 核心方法put和getc// 设置键值对int lru_cache_put(lru_cache_t *cache, const char *key, void *value, int ttl_seconds) {if (!cache || !key) return -1;pthread_mutex_lock(cache-mutex);// 检查是否已存在lru_node_t *node hash_table_get(cache, key);if (node) {// 更新现有节点free(node-value);node-value value;node-expire_time ttl_seconds 0 ? time(NULL) ttl_seconds : 0;// 移到头部move_to_head(cache, node);pthread_mutex_unlock(cache-mutex);return 0;}// 创建新节点node malloc(sizeof(lru_node_t));if (!node) {pthread_mutex_unlock(cache-mutex);return -1;}node-key strdup(key);node-value value;node-expire_time ttl_seconds 0 ? time(NULL) ttl_seconds : 0;node-prev NULL;node-next NULL;// 检查容量if (cache-count cache-capacity) {// 淘汰最久未使用的节点lru_node_t *tail pop_tail(cache);if (tail) {hash_table_remove(cache, tail-key);free_node(tail);cache-count--;}}// 插入新节点到头部node-next cache-head;if (cache-head) {cache-head-prev node;}cache-head node;if (!cache-tail) {cache-tail node;}// 添加到哈希表hash_table_put(cache, key, node);cache-count;pthread_mutex_unlock(cache-mutex);return 0;}// 获取键对应的值void* lru_cache_get(lru_cache_t *cache, const char *key) {if (!cache || !key) return NULL;pthread_mutex_lock(cache-mutex);lru_node_t *node hash_table_get(cache, key);if (!node) {cache-misses;pthread_mutex_unlock(cache-mutex);return NULL;}// 检查是否过期if (node-expire_time 0 time(NULL) node-expire_time) {// 过期了删除节点remove_node(cache, node);hash_table_remove(cache, key);free_node(node);cache-count--;cache-misses;pthread_mutex_unlock(cache-mutex);return NULL;}// 移动到头部move_to_head(cache, node);cache-hits;pthread_mutex_unlock(cache-mutex);return node-value;}7. 统计和调试接口c// 获取命中率float lru_cache_hit_rate(lru_cache_t *cache) {long long total cache-hits cache-misses;if (total 0) return 0;return (float)cache-hits / total;}// 获取命中次数long long lru_cache_hits(lru_cache_t *cache) {return cache-hits;}// 获取未命中次数long long lru_cache_misses(lru_cache_t *cache) {return cache-misses;}// 获取当前缓存大小int lru_cache_size(lru_cache_t *cache) {return cache-count;}// 清空缓存void lru_cache_clear(lru_cache_t *cache) {pthread_mutex_lock(cache-mutex);lru_node_t *node cache-head;while (node) {lru_node_t *next node-next;free_node(node);node next;}memset(cache-hash_table, 0, cache-hash_size * sizeof(lru_node_t*));cache-head NULL;cache-tail NULL;cache-count 0;pthread_mutex_unlock(cache-mutex);}// 打印缓存内容调试用void lru_cache_print(lru_cache_t *cache) {pthread_mutex_lock(cache-mutex);printf(LRU Cache (head → tail): );lru_node_t *node cache-head;while (node) {printf(%s , node-key);node node-next;}printf(\n);pthread_mutex_unlock(cache-mutex);}---三、测试代码基础功能测试cint main() {// 创建容量为3的LRU缓存lru_cache_t *cache lru_cache_create(3, 16);printf( LRU缓存基础测试 \n\n);// 插入数据int *v1 malloc(sizeof(int)); *v1 100;int *v2 malloc(sizeof(int)); *v2 200;int *v3 malloc(sizeof(int)); *v3 300;int *v4 malloc(sizeof(int)); *v4 400;lru_cache_put(cache, A, v1, 0);lru_cache_put(cache, B, v2, 0);lru_cache_put(cache, C, v3, 0);lru_cache_print(cache); // 期望: A B C 或 C B A取决于实现细节// 访问BB应该移到头部printf(访问B\n);int *val lru_cache_get(cache, B);printf(获取B: %d\n, val ? *val : -1);lru_cache_print(cache);// 插入D容量3应该淘汰最久未使用的Aprintf(插入D\n);lru_cache_put(cache, D, v4, 0);lru_cache_print(cache);// 尝试获取A应该不存在val lru_cache_get(cache, A);printf(获取A: %s\n, val ? 存在 : 不存在已被淘汰);// 统计printf(\n 统计信息 \n);printf(命中次数: %lld\n, lru_cache_hits(cache));printf(未命中次数: %lld\n, lru_cache_misses(cache));printf(命中率: %.2f%%\n, lru_cache_hit_rate(cache) * 100);printf(当前大小: %d\n, lru_cache_size(cache));lru_cache_destroy(cache);return 0;}运行结果 LRU缓存基础测试 LRU Cache (head → tail): C B A访问B获取B: 200LRU Cache (head → tail): B C A插入DLRU Cache (head → tail): D B C获取A: 不存在已被淘汰 统计信息 命中次数: 1未命中次数: 1命中率: 50.00%当前大小: 3过期时间测试cvoid test_expiration() {lru_cache_t *cache lru_cache_create(10, 32);printf(\n 过期时间测试 \n);int *v malloc(sizeof(int)); *v 123;lru_cache_put(cache, temp, v, 2); // 2秒后过期printf(立即获取: %d\n, *(int*)lru_cache_get(cache, temp));printf(等待3秒...\n);sleep(3);void *result lru_cache_get(cache, temp);printf(3秒后获取: %s\n, result ? 存在 : 已过期);lru_cache_destroy(cache);}并发测试c#include pthread.h#include unistd.hlru_cache_t *global_cache;int stop 0;int test_counter 0;void *worker_read(void *arg) {int id *(int*)arg;char key[16];for (int i 0; i 10000 !stop; i) {snprintf(key, sizeof(key), key_%d, rand() % 20);void *val lru_cache_get(global_cache, key);// 模拟工作usleep(1);}return NULL;}void *worker_write(void *arg) {int id *(int*)arg;char key[16];for (int i 0; i 2000 !stop; i) {snprintf(key, sizeof(key), key_%d, rand() % 20);int *val malloc(sizeof(int));*val id * 1000 i;lru_cache_put(global_cache, key, val, 0);usleep(10);}return NULL;}void test_concurrent() {global_cache lru_cache_create(100, 128);pthread_t readers[10], writers[5];int ids[15];printf(\n 并发测试 \n);printf(启动10个读线程5个写线程...\n);for (int i 0; i 10; i) {ids[i] i;pthread_create(readers[i], NULL, worker_read, ids[i]);}for (int i 0; i 5; i) {ids[10 i] i;pthread_create(writers[i], NULL, worker_write, ids[10 i]);}sleep(5);stop 1;for (int i 0; i 10; i) {pthread_join(readers[i], NULL);}for (int i 0; i 5; i) {pthread_join(writers[i], NULL);}printf(最终缓存大小: %d\n, lru_cache_size(global_cache));printf(命中率: %.2f%%\n, lru_cache_hit_rate(global_cache) * 100);lru_cache_destroy(global_cache);}---四、性能优化技巧1. 减少锁竞争c// 方案分段锁typedef struct {lru_cache_t *segments[16];pthread_mutex_t segment_locks[16];} segmented_lru_t;unsigned int get_segment_index(const char *key) {return lru_hash(key, 16);}void *segmented_get(segmented_lru_t *cache, const char *key) {int idx get_segment_index(key);pthread_mutex_lock(cache-segment_locks[idx]);void *val lru_cache_get(cache-segments[idx], key);pthread_mutex_unlock(cache-segment_locks[idx]);return val;}2. 使用内存池c// 预分配节点减少malloc开销typedef struct {lru_node_t *free_list;pthread_mutex_t pool_lock;} node_pool_t;lru_node_t *node_pool_alloc(node_pool_t *pool) {pthread_mutex_lock(pool-pool_lock);if (pool-free_list) {lru_node_t *node pool-free_list;pool-free_list node-next;pthread_mutex_unlock(pool-pool_lock);return node;}pthread_mutex_unlock(pool-pool_lock);return malloc(sizeof(lru_node_t));}3. 提升缓存友好性c// 将key和value连续存储typedef struct {char key[64]; // 固定长度避免指针跳转char value[256];time_t expire_time;struct lru_node *prev;struct lru_node *next;} compact_node_t;---五、LRU的应用场景场景 说明 典型产品数据库缓冲池 缓存热点数据页 MySQL InnoDB Buffer PoolRedis淘汰策略 内存不足时淘汰key Redis maxmemory-policy浏览器缓存 后退/前进按钮 Chrome Back/Forward CacheCDN缓存 边缘节点缓存热门内容 CloudFront, Akamai操作系统页缓存 缓存磁盘数据页 Linux Page Cache---六、与其他淘汰算法对比算法 原理 优点 缺点LRU 淘汰最久未使用 实现简单局部性好 扫描一次会污染LFU 淘汰使用次数最少 抗扫描 需要维护频率ARC 自适应LRULFU 效果好 实现复杂FIFO 淘汰最早进入 极简单 效果差---七、总结通过这篇文章你学会了· LRU缓存的核心原理哈希表 双向链表· 完整的生产级实现支持过期、统计、并发· 性能优化技巧分段锁、内存池· 实际应用场景这个LRU缓存可以直接用于你的项目。把它改成更通用的模板版本加上更多配置选项就是一个完整的缓存组件。下一篇预告《从LRU到LFU手写一个自适应缓存淘汰算法》---评论区分享一下你用LRU解决过什么问题