LFU算法及其优化策略——算法篇
前不久写了LRU算法系列文章，今天来介绍一下和LRU算法并驾齐驱的另一个算法——LFU。
LFU全称是最不经常使用算法（Least Frequently Used），LFU算法的基本思想和所有的缓存算法一样，都是基于locality假设（局部性原理）：
如果一个信息项正在被访问，那么在近期它很可能还会被再次访问。
LFU是基于这种思想进行设计：一定时期内被访问次数最少的页，在将来被访问到的几率也是最小的。
相比于LRU（Least Recently Use）算法，LFU更加注重于使用的频率。
原理
LFU将数据和数据的访问频次保存在一个容量有限的容器中，当访问一个数据时：
- 该数据在容器中，则将该数据的访问频次加1。
- 该数据不在容器中，则将该数据加入到容器中，且访问频次为1。
当数据量达到容器的限制后，会剔除掉访问频次最低的数据。下图是一个简易的LFU算法示意图。
上图中的LRU容器是一个链表，会动态地根据访问频次调整数据在链表中的位置，方便进行数据的淘汰，可以看到，在第四步时，因为需要插入数据F，而淘汰了数据E。
LFU实现
LFU的实现一共有三种方案，但是思想都是一样的，下面我们先来看最简单的一种实现。
基于双端链表+哈希表
public class LFUCache {
private Node head; // 头结点 简化null判断
private Node tail; // 尾结点 简化null判断
private int capacity; // 容量限制
private int size; // 当前数据个数
private Map<Integer, Node> map; // key和数据的映射
public LFUCache(int capacity) {
this.capacity = capacity;
this.size = 0;
this.head = new Node(0, 0, 0);
this.tail = new Node(0, 0, 0);
this.head.next = tail;
this.tail.pre = head;
this.map = new HashMap<>();
}
public int get(int key) {
// 从哈希表中判断数据是否存在
Node node = map.get(key);
if (node == null) {
return -1;
}
// 如果存在则增加该数据的访问频次
freqPlus(node);
return node.value;
}
public void put(int key, int value) {
if (capacity <= 0) {
return;
}
Node node = map.get(key);
if (node != null) {
// 如果存在则增加该数据的访问频次
node.value = value;
freqPlus(node);
} else {
// 淘汰数据
eliminate();
Node newNode = new Node(key, value, 0);
map.put(key, newNode);
size++;
// 将新数据插入到末尾
Node tailPre = tail.pre;
tail.pre = newNode;
newNode.pre = tailPre;
newNode.next = tail;
tailPre.next = newNode;
// 增加访问频次
freqPlus(newNode);
}
}
private void freqPlus(Node node) {
node.frequency++;
Node temp = node.pre;
int freq = node.frequency;
while(temp != null) {
// 使用大于号的原因是将最后访问的数据排在旧数据之前
if (temp.frequency > freq || temp == head) {
node.pre.next = node.next;
node.next.pre = node.pre;
// 根据访问频次排序调整位置
Node tempNext = temp.next;
temp.next = node;
tempNext.pre = node;
node.next = tempNext;
node.pre = temp;
break;
}
temp = temp.pre;
}
}
private void eliminate() {
if (size < capacity) {
return;
}
// 从尾结点的pre节点之间删除即可
Node last = tail.pre;
last.pre.next = tail;
tail.pre = last.pre;
map.remove(last.key);
size--;
last = null;
}
}
class Node {
int key;
int value;
int frequency;
Node pre;
Node next;
Node(int key, int value, int frequency) {
this.key = key;
this.value = value;
this.frequency = frequency;
}
}
整个逻辑还是比较清晰的，注意小心的操纵pre（前置节点）、next（后置节点）这两个指针即可，同时注意通过freqPlus()方法保证链表中的数据是按照访问频次排序的。
也正是因为freqPlus这个方法，导致put()和get()操作的时间复杂度都为O(N)。
基于双哈希表实现
为了进一步降低上一种方案的时间复杂度，我们可以通过双哈希表来实现。
class LFUCache {
private int capacity; // 容量限制
private int size; // 当前数据个数
private int minFreq; // 当前最小频率
private Map<Integer, Node> map; // key和数据的映射
private Map<Integer, LinkedHashSet<Node>> freqMap; // 数据频率和对应数据组成的链表
public LFUCache(int capacity) {
this.capacity = capacity;
this.size = 0;
this.minFreq = 1;
this.map = new HashMap<>();
this.freqMap = new HashMap<>();
}
public int get(int key) {
Node node = map.get(key);
if (node == null) {
return -1;
}
// 增加数据的访问频率
freqPlus(node);
return node.value;
}
public void put(int key, int value) {
if (capacity <= 0) {
return;
}
Node node = map.get(key);
if (node != null) {
// 如果存在则增加该数据的访问频次
node.value = value;
freqPlus(node);
} else {
// 淘汰数据
eliminate();
// 新增数据并放到数据频率为1的数据链表中
Node newNode = new Node(key, value);
map.put(key, newNode);
LinkedHashSet<Node> set = freqMap.get(1);
if (set == null) {
set = new LinkedHashSet<>();
freqMap.put(1, set);
}
set.add(newNode);
minFreq = 1;
size++;
}
}
private void eliminate() {
if (size < capacity) {
return;
}
LinkedHashSet<Node> set = freqMap.get(minFreq);
Node node = set.iterator().next();
set.remove(node);
map.remove(node.key);
size--;
}
void freqPlus(Node node) {
int frequency = node.frequency;
LinkedHashSet<Node> oldSet = freqMap.get(frequency);
oldSet.remove(node);
// 更新最小数据频率
if (minFreq == frequency && oldSet.isEmpty()) {
minFreq++;
}
frequency++;
node.frequency++;
LinkedHashSet<Node> set = freqMap.get(frequency);
if (set == null) {
set = new LinkedHashSet<>();
freqMap.put(frequency, set);
}
set.add(node);
}
}
class Node {
int key;
int value;
int frequency = 1;
Node(int key, int value) {
this.key = key;
this.value = value;
}
}
基于JDK的LinkedHashSet这个类来模拟链表，我们可以将put()和get()操作的时间复杂度降低到O(1)级别。这套方案的实现来自于这篇论文《An O(1) algorithm for implementing the LFU cache eviction scheme》，下面是该论文中的一个示意图，可以辅助理解。
LFU相比于LRU的优劣
区别：
LFU是基于访问频次的模式，而LRU是基于访问时间的模式。
优势：
在数据访问符合正态分布时，相比于LRU算法，LFU算法的缓存命中率会高一些。
劣势：
- LFU的复杂度要比LRU更高一些。
- 需要维护数据的访问频次，每次访问都需要更新。
- 早期的数据相比于后期的数据更容易被缓存下来，导致后期的数据很难被缓存。
- 新加入缓存的数据很容易被剔除，像是缓存的末端发生“抖动”。
LFU算法优化
从上面的优劣分析中我们可以发现，优化LFU算法可以从下面几点入手：
- 更加紧凑的数据结构，避免维护访问频次的高消耗。
- 避免早期的热点数据一直占据缓存，即LFU算法也需有一些访问时间模式的特性。
- 消除缓存末端的抖动。
具体的优化方案我会在之后的文章中结合具体实例进行介绍。
总结
本文介绍了基本的LFU算法，以及它的O(N)级别和O(1)级别的具体实现。后面进行了LRU算法和LFU算法的优劣分析，并得出了LFU算法的优化方向。
