LRU（Least Recently Used）作为最经典的缓存淘汰策略之一，广泛应用于操作系统、数据库、Web框架等场景。本文我将深入解析LRU缓存的核心原理、数据结构设计、算法实现及优化策略，结合Java代码实现，帮你掌握高性能缓存系统的设计方法。

一、LRU缓存核心概念

1.1 LRU策略定义

LRU缓存通过维护一个「最近使用」的顺序列表，当缓存容量已满时，主动淘汰最近最少使用的元素，为新元素腾出空间。其核心思想是：优先保留近期使用过的数据，淘汰长时间未访问的数据。

1.2 应用场景

• 浏览器缓存：存储最近访问的网页资源，加速页面加载
• 数据库查询缓存：缓存高频访问的SQL结果，减少数据库压力
• Java内存管理：JVM堆内存中的LRU机制优化对象回收
• 分布式系统：Redis的allkeys-lru策略提升热点数据访问效率

1.3 核心操作要求

• get(key)：获取指定键的值，若存在则返回并标记为最近使用，时间复杂度O(1)
• put(key, value)：插入或更新键值对，若容量不足则淘汰最近最少使用的键，时间复杂度O(1)

二、数据结构设计：双向链表+哈希表

2.1 为什么选择双向链表？

• 有序性维护：链表天然支持顺序访问，方便将最近使用的节点移动到头部
• 快速删除：双向链表可在O(1)时间内删除任意节点（需前驱节点指针）
• 高效插入：新节点始终插入头部，旧节点淘汰从尾部移除

2.2 为什么结合哈希表？

• 快速定位：哈希表存储键到节点的映射，实现O(1)时间的存在性检查
• 解耦数据：链表维护顺序，哈希表维护键的索引，分工明确

2.3 节点结构设计（双向链表）

class Node {int key;        // 键（用于哈希表定位）int value;      // 值Node prev;      // 前驱节点Node next;      // 后继节点public Node(int key, int value) {this.key = key;this.value = value;}
}

2.4 LRU缓存的逻辑结构

哈希表 (key -> Node)↓
双向链表（头节点=最近使用，尾节点=最久未使用）
head <-> node1 <-> node2 <-> ... <-> tail

三、核心算法实现

3.1 初始化参数

import java.util.HashMap;public class LRUCache {private HashMap<Integer, Node> cache;  // 键到节点的映射private int capacity;                 // 缓存容量private Node head;                    // 最近使用节点（头节点）private Node tail;                    // 最久未使用节点（尾节点）public LRUCache(int capacity) {this.capacity = capacity;cache = new HashMap<>(capacity);// 初始化虚拟头尾节点，简化边界处理head = new Node(-1, -1);tail = new Node(-1, -1);head.next = tail;tail.prev = head;}
}

3.2 get方法实现（获取并更新顺序）

public int get(int key) {if (!cache.containsKey(key)) {return -1;}Node node = cache.get(key);// 将节点移动到头部removeNode(node);addToHead(node);return node.value;
}// 私有方法：删除任意节点
private void removeNode(Node node) {Node prevNode = node.prev;Node nextNode = node.next;prevNode.next = nextNode;nextNode.prev = prevNode;
}// 私有方法：将节点插入头部
private void addToHead(Node node) {node.next = head.next;node.prev = head;head.next.prev = node;head.next = node;
}

3.3 put方法实现（插入/更新+淘汰策略）

public void put(int key, int value) {if (cache.containsKey(key)) {// 更新值并移动到头部Node node = cache.get(key);node.value = value;removeNode(node);addToHead(node);return;}if (cache.size() == capacity) {// 淘汰尾节点（最久未使用）Node lastNode = tail.prev;cache.remove(lastNode.key);removeNode(lastNode);}// 插入新节点到头部Node newNode = new Node(key, value);cache.put(key, newNode);addToHead(newNode);
}

3.4 复杂度分析

• 时间复杂度：
  get和put操作均通过哈希表定位节点（O(1)），双向链表的删除和插入操作均为O(1)，总体时间复杂度O(1)
• 空间复杂度：
  存储所有节点的空间为O(capacity)，哈希表和链表的额外空间为O(capacity)，总体空间复杂度O(capacity)

四、边界处理与优化技巧

4.1 虚拟头尾节点设计

• 作用：避免处理头节点和尾节点的null指针边界问题
• 实现：初始化两个虚拟节点，头节点的next指向最近使用节点，尾节点的prev指向最久未使用节点

4.2 容量为1的极端情况

// 测试用例：容量为1时，每次put都会淘汰旧节点
LRUCache cache = new LRUCache(1);
cache.put(1, 10);  // 缓存：{1:10}
cache.put(2, 20);  // 淘汰1，缓存：{2:20}
System.out.println(cache.get(1));  // 输出-1

4.3 线程安全优化

• 问题：上述实现非线程安全，多线程环境下需加锁
• 解决方案：
  使用synchronized修饰get/put方法，或基于ReentrantLock实现：

private final ReentrantLock lock = new ReentrantLock();public int get(int key) {lock.lock();try {// 原有逻辑} finally {lock.unlock();}
}

五、Java内置实现：LinkedHashMap

5.1 利用LinkedHashMap实现LRU

import java.util.LinkedHashMap;public class LRUCacheJava {private LinkedHashMap<Integer, Integer> cache;private int capacity;public LRUCacheJava(int capacity) {this.capacity = capacity;// accessOrder=true表示按访问顺序排序（最近访问的在尾部）cache = new LinkedHashMap<Integer, Integer>(capacity, 0.75f, true) {@Overrideprotected boolean removeEldestEntry(java.util.Map.Entry<Integer, Integer> eldest) {return size() > capacity;}};}public int get(int key) {return cache.getOrDefault(key, -1);}public void put(int key, int value) {cache.put(key, value);}
}

5.2 LinkedHashMap原理

• 数据结构：哈希表+双向链表（维护插入顺序或访问顺序）
• 淘汰策略：重写removeEldestEntry方法，容量超标时淘汰最旧节点
• 性能对比：比手动实现稍慢（封装带来的开销），但代码更简洁

六、分布式LRU缓存设计（进阶）

6.1 一致性哈希算法

• 问题：分布式环境中缓存节点动态变化时的键分布问题
• 解决方案：
  通过一致性哈希将键映射到节点，节点增减时仅影响相邻节点，减少缓存失效

6.2 缓存穿透与雪崩

• 缓存穿透：查询不存在的键导致大量数据库访问
  解决方案：缓存空值或布隆过滤器
• 缓存雪崩：大量缓存同时失效导致请求积压
  解决方案：设置随机过期时间+多级缓存

6.3 典型架构

客户端 <-> 负载均衡 <-> 缓存集群（每个节点实现LRU）↓数据源（数据库/文件系统）

LRU总结

LRU的优缺点

优点	缺点
实现相对简单	无法处理突发访问模式
适合时间局部性数据	对空间局部性支持差
平均性能稳定	可能淘汰高频低最近使用数据

适用场景

• 优先使用：数据访问符合时间局部性（如历史记录、用户行为数据）
• 谨慎使用：数据访问模式频繁变化（如实时统计类数据）
• 结合使用：与LFU（最少频率使用）策略结合，提升复杂场景性能

优化建议

1. 预加载热点数据：初始化时加载高频访问数据
2. 限制最大容量：避免内存溢出，结合监控动态调整容量
3. 异步淘汰：将淘汰操作放到后台线程执行，减少主线程阻塞

That’s all, thanks for reading!
觉得有用就点个赞、收进收藏夹吧！关注我，获取更多干货～