深入理解 LFU 缓存算法：原理、应用与优化

深入理解 LFU 缓存算法：原理、应用与优化

引用

CSDN

1.

https://blog.csdn.net/why_still_confused/article/details/138345197

LFU（Least Frequently Used）算法是一种缓存淘汰策略，它根据数据被访问的频率来淘汰数据。LFU算法的核心思想是：如果数据被访问的频率较低，那么它在未来被访问的可能性也较低，因此可以优先考虑淘汰这些数据。

• 频率计数：LFU算法为每个缓存项维护一个频率计数器，用于记录该项被访问的次数。
• 淘汰策略：当需要淘汰数据以腾出空间时，LFU算法会选择频率最低的缓存项进行淘汰

LFU 适用场景

LFU 算法适用于具有以下特点的场景：

1. 操作系统缓存：操作系统可以使用LFU算法来管理磁盘缓存或页面缓存。LFU算法可以在内存中保留最常使用的数据页，以提高系统的性能。
2. Web服务器缓存：Web服务器可以使用LFU算法来缓存最常请求的网页或资源。这可以减少服务器的负载并提高响应时间，特别是对于经常被访问的网页或资源。
3. 数据库缓存：数据库管理系统可以使用LFU算法来缓存最常被访问的数据页或查询结果。这可以加快数据库的读取操作并减少磁盘IO。
4. 内容分发网络（CDN）：CDN是一种分布式系统，用于缓存和分发静态和动态内容。LFU算法可以帮助CDN节点确定最常请求的内容，并将其缓存在离用户更近的位置，以提高内容的访问速度

LFU 实现

数据结构：通常使用哈希表和有序数据结构（如最小堆或有序链表）来实现LFU算法。哈希表用于快速访问缓存项，有序数据结构用于维护数据项的访问频率顺序

缓存容量：LFU 算法需要指定缓存的容量，即可以存储的数据项数量上限。当缓存已满时，需要进行替换操作。

• get操作：
• 当请求缓存中的某个键时，如果该键存在，增加其频率计数器，并返回对应的值。
• put操作：
• 如果是新键，则添加到缓存中，初始化其频率计数器，并在frequence中创建新的频率键集合。
• 如果键已存在，更新其对应的值，并增加频率计数器。
• 如果缓存已满，移除frequence频率集合中使用次数最小的键，并更新frequence

理想情况下，每个get和put操作的时间复杂度为O(1)，这取决于哈希表和有序数据结构的访问效率。

class LFUCache {
     int capacity;
     int size;
     Map<Integer, CacheItem<Integer, Integer>> cache;
     Map<Integer, Set<Integer>> frequency;
    public LFUCache(int capacity) {
        this.capacity = capacity;
        size = 0;
        cache = new HashMap<>();
        frequency = new TreeMap<>();
    }
    
    public int get(int key) {
        if(!cache.containsKey(key)){
            return -1;
        }
        CacheItem<Integer, Integer> item = cache.get(key);
        updateItemUsage(item);
        return item.value;
    }
    
    public void put(int key, int value) {
        if(capacity == 0){
            return;
        }
        if(cache.containsKey(key)){
            CacheItem<Integer, Integer> item = cache.get(key);
            item.value = value;
            updateItemUsage(item);
        } else {
            if(size >= capacity){
                evictLFUItem();
            }
            CacheItem<Integer, Integer> item = new CacheItem<>(key, value);
            addToFrequencyMap(item);
            cache.put(key, item);
            size++;
        }
    }
    private void updateItemUsage(CacheItem<Integer, Integer> item) {
        int cnt = item.useCount;
        Set<Integer> items = frequency.get(cnt);
        items.remove(item.key);
        if(items.isEmpty()){
            frequency.remove(cnt);
        }
        item.incrementUsageCount();
        addToFrequencyMap(item);
    }
    private void addToFrequencyMap(CacheItem<Integer, Integer> item) {
        int cnt = item.useCount;
        frequency.computeIfAbsent(cnt, k -> new LinkedHashSet<>()).add(item.key);
    }
    private void evictLFUItem() {
        Set<Integer> items = frequency.entrySet().iterator().next().getValue();
        int evictKey = items.iterator().next();
        items.remove(evictKey);
        if (items.isEmpty()) {
            frequency.remove(1);
        }
        cache.remove(evictKey);
        size--;
    }
    class CacheItem<K, V> {
        K key;
        V value;
        int useCount;
        public CacheItem(K key, V value) {
            this.key = key;
            this.value = value;
            this.useCount = 1;
        }
        public void incrementUsageCount() {
            useCount++;
        }
    }
}