缓存策略---LRU缓存

最新推荐文章于 2025-06-02 17:26:43 发布

原创最新推荐文章于 2025-06-02 17:26:43 发布 · 876 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#缓存

LRU缓存是一种常用的内存管理策略，当缓存满时会移除最近最少使用的数据。本文介绍了LRU的工作原理，并详细讲解了两种实现方式：1) 使用LinkedHashMap，通过重写其内部方法实现；2) 结合双链表和hashtable，利用链表维护访问顺序并实现缓存淘汰。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、介绍

LRU是Least Recently Used 的缩写，翻译过来就是“最近最少使用”。
缓存有一定的大小限制，当没有满时，可以向缓存中添加；当满时，LRU缓存把最近最少使用的数据移除，让给最新读取的数据；
而往往最常读取的，也是读取次数最多的，所以，利用LRU缓存，我们能够提高系统的performance。

2、LRU cache的实现

按照访问顺序维护缓存中数据，当访问一个时，则需要改变该数据的顺序；当添加一个新的数据时，则顺序添加即可；当缓存满时，则删除访问顺序中的最后一个；

2.1 LinkedHashMap的实现

1）元素的组织：
LinkedHashMap实现了顺序存储，默认情况下是按照元素的添加顺序存储（最新添加的在最前面），也可以启用按照访问顺序存储（即最近读取的数据放在最前面，最早读取的数据放在最后面）；

public LinkedHashMap(int initialCapacity,
                     float loadFactor,
                     boolean accessOrder)
构造一个带指定初始容量、加载因子和排序模式的空 LinkedHashMap 实例。
参数：
initialCapacity - 初始容量
loadFactor - 加载因子
accessOrder - 排序模式 - 对于访问顺序，为 true；对于插入顺序，则为 false

2）元素的访问：
需要快速访问；LinkedHashMap有hashMap的性质，可以实现o（1）访问；
3）缓存大小的限制；
4）缓存中移除最近最少使用：
LinkedHashMap有一个判断是否删除最老数据的方法，默认是返回false，即不删除数据；我们需要对该方法进行重写；

protected boolean removeEldestEntry(Map.Entry<K,V> eldest)
如果此映射移除其最旧的条目，则返回 true。在将新条目插入到映射后， put 和 putAll 将调用此方法。此方法可以提供在每次添加新条目时移除最旧条目的实现程序。如果映射表示缓存，则此方法非常有用：它允许映射通过删除旧条目来减少内存损耗。

实现方法1（继承LinkedHashMap）：

package cn.lzrabbit.structure.lru;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Created by liuzhao on 14-5-15.
 */
public class LRUCache2<K, V> extends LinkedHashMap<K, V> {
    private final int MAX_CACHE_SIZE;

    public LRUCache2(int cacheSize) {
        super((int) Math.ceil(cacheSize / 0.75) + 1, 0.75f, true);
        MAX_CACHE_SIZE = cacheSize;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry eldest) {
        return size() > MAX_CACHE_SIZE;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<K, V> entry : entrySet()) {
            sb.append(String.format("%s:%s ", entry.getKey(), entry.getValue()));
        }
        return sb.toString();
    }
}

实现方法2（LinkedHashMap代理）：

package cn.lzrabbit.structure.lru;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

/**
 * Created by liuzhao on 14-5-13.
 */
public class LRUCache3<K, V> {

    private final int MAX_CACHE_SIZE;
    private final float DEFAULT_LOAD_FACTOR = 0.75f;
    LinkedHashMap<K, V> map;

    public LRUCache3(int cacheSize) {
        MAX_CACHE_SIZE = cacheSize;
        //根据cacheSize和加载因子计算hashmap的capactiy，+1确保当达到cacheSize上限时不会触发hashmap的扩容，
        int capacity = (int) Math.ceil(MAX_CACHE_SIZE / DEFAULT_LOAD_FACTOR) + 1;
        map = new LinkedHashMap(capacity, DEFAULT_LOAD_FACTOR, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry eldest) {
                return size() > MAX_CACHE_SIZE;
            }
        };
    }

    public synchronized void put(K key, V value) {
        map.put(key, value);
    }

    public synchronized V get(K key) {
        return map.get(key);
    }

    public synchronized void remove(K key) {
        map.remove(key);
    }

    public synchronized Set<Map.Entry<K, V>> getAll() {
        return map.entrySet();
    }

    public synchronized int size() {
        return map.size();
    }

    public synchronized void clear() {
        map.clear();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry entry : map.entrySet()) {
            sb.append(String.format("%s:%s ", entry.getKey(), entry.getValue()));
        }
        return sb.toString();
    }
}

2.2 双链表 + hashtable

用hashtable存放缓存数据；并将hashtable中的缓存数据用双链表连接起来；
获取数据，根据hashtable的性质实现快速获取；
利用链表的性质维护顺序，实现最近最少使用；（当一个位置被命中之后，就将通过调整链表的指向，将该位置调整到链表头的位置，新加入的Cache直接加到链表头中。这样，在多次进行Cache操作后，最近被命中的，就会被向链表头方向移动，而没有命中的，而想链表后面移动，链表尾则表示最近最少使用的Cache。当需要替换内容时候，链表的最后位置就是最少被命中的位置，我们只需要淘汰链表最后的部分即可。）


public class LRUCache {

    private int cacheSize;
    private Hashtable<Object, Entry> nodes;//缓存容器
    private int currentSize;
    private Entry first;//链表头
    private Entry last;//链表尾

    public LRUCache(int i) {
        currentSize = 0;
        cacheSize = i;
        nodes = new Hashtable<Object, Entry>(i);//缓存容器
    }

    /**
     * 获取缓存中对象,并把它放在最前面
     */
    public Entry get(Object key) {
        Entry node = nodes.get(key);
        if (node != null) {
            moveToHead(node);
            return node;
        } else {
            return null;
        }
    }

    /**
     * 添加 entry到hashtable, 并把entry 
     */
    public void put(Object key, Object value) {
        //先查看hashtable是否存在该entry, 如果存在，则只更新其value
        Entry node = nodes.get(key);

        if (node == null) {
            //缓存容器是否已经超过大小.
            if (currentSize >= cacheSize) {
                nodes.remove(last.key);
                removeLast();
            } else {
                currentSize++;
            }           
            node = new Entry();
        }
        node.value = value;
        //将最新使用的节点放到链表头，表示最新使用的.
        moveToHead(node);
        nodes.put(key, node);
    }

    /**
     * 将entry删除, 注意：删除操作只有在cache满了才会被执行
     */
    public void remove(Object key) {
        Entry node = nodes.get(key);
        //在链表中删除
        if (node != null) {
            if (node.prev != null) {
                node.prev.next = node.next;
            }
            if (node.next != null) {
                node.next.prev = node.prev;
            }
            if (last == node)
                last = node.prev;
            if (first == node)
                first = node.next;
        }
        //在hashtable中删除
        nodes.remove(key);
    }

    /**
     * 删除链表尾部节点，即使用最后 使用的entry
     */
    private void removeLast() {
        //链表尾不为空,则将链表尾指向null. 删除连表尾（删除最少使用的缓存对象）
        if (last != null) {
            if (last.prev != null)
                last.prev.next = null;
            else
                first = null;
            last = last.prev;
        }
    }

    /**
     * 移动到链表头，表示这个节点是最新使用过的
     */
    private void moveToHead(Entry node) {
        if (node == first)
            return;
        if (node.prev != null)
            node.prev.next = node.next;
        if (node.next != null)
            node.next.prev = node.prev;
        if (last == node)
            last = node.prev;
        if (first != null) {
            node.next = first;
            first.prev = node;
        }
        first = node;
        node.prev = null;
        if (last == null)
            last = first;
    }
    /*
     * 清空缓存
     */
    public void clear() {
        first = null;
        last = null;
        currentSize = 0;
    }

}

class Entry {
    Entry prev;//前一节点
    Entry next;//后一节点
    Object value;//值
    Object key;//键
}