缓存淘汰策略看完这篇就够了

澄风

已于 2024-03-06 13:43:15 修改

阅读量1.6k

点赞数 20

分类专栏： redis 杂项文章标签：缓存 redis Caffeine ehcache guava

于 2024-03-05 11:28:09 首次发布

本文链接：https://blog.csdn.net/yh4494/article/details/136473713

版权

杂项同时被 2 个专栏收录

11 篇文章 2 订阅

订阅专栏

redis

2 篇文章 0 订阅

订阅专栏

LFU 缓存淘汰算法

LFU 是 Least Frequently Used 的缩写，即最少使用缓存淘汰算法。LFU算法根据数据项在缓存中的访问频率来决定淘汰哪些数据项。访问频率越高的数据项被认为是更重要的，访问频率越低的数据项被认为是更不重要的。

LFU算法的具体工作原理如下：

每个数据项在缓存中都有一个计数器，用于记录该数据项被访问的次数。
当缓存空间不足时，LFU算法会淘汰计数器值最小的数据项。
当数据项被访问时，其计数器值会加 1。

在这里插入图片描述

LFU算法的优点如下：

简单易行：LFU算法的实现比较简单，易于理解和维护。
公平性：LFU算法可以保证经常使用的数据项不会被淘汰，具有一定的公平性。
LFU算法的缺点如下：
不准确：LFU算法只考虑数据项的访问频率，而不考虑数据项的访问时间。因此，LFU算法可能会淘汰最近访问过的数据项，导致缓存命中率下降。
空间复杂度：LFU算法需要为每个数据项维护一个计数器，这会增加缓存的空间复杂度。

LFU算法的应用场景

LFU算法常用于对缓存命中率要求不高的场景，例如：

Web 缓存：Web 缓存中存储的通常是静态数据，例如图片、CSS 和 JavaScript 文件。这些数据的访问频率通常是固定的，因此使用 LFU 算法可以有效地提高缓存空间的利用率。
数据库缓存：数据库缓存中存储的通常是经常访问的数据。这些数据的访问频率可能会随着时间的推移而变化，因此使用 LFU 算法可以保证经常使用的数据项不会被淘汰。

LFU算法的改进

为了克服 LFU 算法的缺点，人们提出了改进的 LFU 算法，例如：

LFU-A：LFU-A 算法不仅考虑数据项的访问频率，还考虑数据项的访问时间。当缓存空间不足时，LFU-A 算法会淘汰访问频率低且访问时间最久的数据项。
LFU-D：LFU-D 算法使用衰减计数器来记录数据项的访问频率。衰减计数器会随着时间的推移而递减，这样可以保证最近访问过的数据项具有更高的计数器值。

总结

LFU 算法是一种常用的缓存淘汰算法，具有简单易行、公平性等优点。但是，LFU 算法也存在不准确、空间复杂度高等缺点。在实际应用中，可以根据具体的应用场景选择合适的缓存淘汰算法。

LRU 缓存淘汰算法

LRU 是 Least Recently Used 的缩写，即最近最少使用缓存淘汰算法。LRU算法根据数据项在缓存中的最近访问时间来决定淘汰哪些数据项。最近访问过的数据项被认为是更重要的，最久未访问的数据项被认为是更不重要的。

LRU算法的具体工作原理如下：

缓存中的数据项使用链表进行存储。
当数据项被访问时，将其移动到链表头部。
当缓存空间不足时，LRU算法会淘汰链表尾部的数据项。

在这里插入图片描述
【算法】用JAVA代码实现LRU 【缓存】【LRU】

LRU算法的优点如下：

简单易行：LRU算法的实现比较简单，易于理解和维护。
有效性：LRU算法可以保证最近访问过的数据项不会被淘汰，可以有效地提高缓存命中率。

LRU算法的缺点如下：

不公平性：LRU算法只考虑数据项的访问时间，而不考虑数据项的访问频率。因此，LRU算法可能会淘汰经常使用的数据项，导致缓存命中率下降。
空间复杂度：LRU算法需要维护一个链表，这会增加缓存的空间复杂度。

LRU算法的应用场景

LRU算法常用于对缓存命中率要求高的场景，例如：

CPU缓存：CPU缓存中存储的是 CPU 即将要访问的数据。这些数据的访问频率是随机的，因此使用 LRU 算法可以有效地提高 CPU 的性能。
内存缓存：内存缓存中存储的是经常访问的数据。这些数据的访问频率可能会随着时间的推移而变化，因此使用 LRU 算法可以保证经常使用的数据项不会被淘汰。

LRU算法的改进

为了克服 LRU 算法的缺点，人们提出了改进的 LRU 算法，例如：

LFU-LRU：LFU-LRU 算法结合了 LFU 算法和 LRU 算法的优点。它不仅考虑数据项的访问频率，还考虑数据项的访问时间。当缓存空间不足时，LFU-LRU 算法会淘汰访问频率低且访问时间最久的数据项。
2Q：2Q 算法使用两个队列来维护缓存中的数据项。一个是访问队列，另一个是淘汰队列。当数据项被访问时，将其加入访问队列。当缓存空间不足时，2Q 算法会淘汰淘汰队列中的数据项。

总结

LRU 算法是一种常用的缓存淘汰算法，具有简单易行、有效性等优点。但是，LRU 算法也存在不公平性、空间复杂度高等缺点。在实际应用中，可以根据具体的应用场景选择合适的缓存淘汰算法。
以下是一些关于 LRU 算法的额外信息：

LRU 算法可以用链表或哈希表来实现。
LRU 算法可以与其他缓存淘汰算法结合使用，例如 LFU 算法。
LRU 算法是一种近似算法，无法保证最优的缓存命中率。
希望以上信息对您有所帮助。

TinyLFU 缓存淘汰算法

TinyLFU 是一种基于频率的缓存淘汰算法，由 Redis 团队在 2018 年提出。TinyLFU 算法旨在在降低空间复杂度的情况下，提供与 LFU 算法相近的缓存命中率。

TinyLFU 算法的工作原理:

TinyLFU 算法使用一个 bitmap 来记录每个数据项的访问频率。bitmap 中的每个 bit 代表一个数据项，bit 的值为 1 表示该数据项在最近一个时间窗口内被访问过，bit 的值为 0 表示该数据项没有被访问过。
当数据项被访问时，TinyLFU 算法会将该数据项对应的 bit 设置为 1。
当缓存空间不足时，TinyLFU 算法会淘汰 bitmap 中 bit 值为 0 的数据项。

在这里插入图片描述

TinyLFU 算法的优点:

空间复杂度低：TinyLFU 算法只需要使用一个 bitmap 来记录数据项的访问频率，因此空间复杂度较低。
性能优良：TinyLFU 算法可以提供与 LFU 算法相近的缓存命中率。

TinyLFU 算法的缺点:

不精确：TinyLFU 算法只考虑数据项的访问频率，而不考虑数据项的访问时间。因此，TinyLFU 算法可能会淘汰最近访问过的数据项，导致缓存命中率下降。
时间窗口大小敏感：TinyLFU 算法的性能依赖于时间窗口的大小。如果时间窗口大小设置过小，TinyLFU 算法可能会频繁淘汰最近访问过的数据项，导致缓存命中率下降。

TinyLFU 算法的应用场景:

TinyLFU 算法常用于对空间复杂度要求较高的场景，例如：

嵌入式系统：嵌入式系统的资源有限，因此需要使用空间复杂度较低的缓存淘汰算法。
移动设备：移动设备的存储空间有限，因此需要使用空间复杂度较低的缓存淘汰算法。

TinyLFU 算法的改进:

为了克服 TinyLFU 算法的缺点，人们提出了改进的 TinyLFU 算法，例如：

TinyLFU-A：TinyLFU-A 算法不仅考虑数据项的访问频率，还考虑数据项的访问时间。当缓存空间不足时，TinyLFU-A 算法会淘汰访问频率低且访问时间最久的数据项。
W-TinyLFU：W-TinyLFU 算法使用加权计数器来记录数据项的访问频率。加权计数器的值会随着时间的推移而衰减，这样可以保证最近访问过的数据项具有更高的计数器值。

总结:

TinyLFU 是一种空间复杂度低、性能优良的缓存淘汰算法。但是，TinyLFU 算法也存在不精确、时间窗口大小敏感等缺点。在实际应用中，可以根据具体的应用场景选择合适的缓存淘汰算法。
以下是一些关于 TinyLFU 算法的额外信息：

TinyLFU 算法可以用 bitmap 或 cuckoo hash table 来实现。
TinyLFU 算法可以与其他缓存淘汰算法结合使用，例如 LRU 算法。
TinyLFU 算法是一种近似算法，无法保证最优的缓存命中率。
希望以上信息对您有所帮助。

W-TinyLFU 缓存淘汰算法

W-TinyLFU 是一种基于频率和时间窗口的缓存淘汰算法，由 Caffeine 缓存框架在 2019 年提出。W-TinyLFU 算法旨在在降低空间复杂度的情况下，提供与 LFU 算法相近的缓存命中率，并克服 TinyLFU 算法对时间窗口大小敏感的缺点。

W-TinyLFU 算法的工作原理:

W-TinyLFU 算法将缓存划分为两个区域：Window Cache 和 Main Cache。
Window Cache 是一个 LRU 缓存，用于存储最近访问过的数据项。
Main Cache 是一个 SLRU 缓存，用于存储访问频率较高的数据项。
当数据项被访问时，W-TinyLFU 算法会将其加入 Window Cache。
当 Window Cache 空间不足时，W-TinyLFU 算法会淘汰 LRU 缓存中的数据项。
当 Main Cache 空间不足时，W-TinyLFU 算法会淘汰访问频率低于阈值的 SLRU 缓存中的数据项。

W-TinyLFU 算法的实现原理:

Window Cache 使用链表来实现。
Main Cache 使用哈希表和链表来实现。
每个数据项都包含一个计数器，用于记录该数据项的访问频率。
计数器的值会随着时间的推移而衰减。
当数据项被访问时，其计数器值会加 1。
当 Window Cache 空间不足时，W-TinyLFU 算法会淘汰链表尾部的数据项。
当 Main Cache 空间不足时，W-TinyLFU 算法会淘汰计数器值低于阈值的哈希表中的数据项。

Java语言简单实现(伪代码)

public class WTinyLFUCache<K, V> {

    private final WindowCache<K, V> windowCache;
    private final MainCache<K, V> mainCache;

    public WTinyLFUCache(int windowCacheSize, int mainCacheSize) {
        this.windowCache = new LRUCache<>(windowCacheSize);
        this.mainCache = new SLRUCache<>(mainCacheSize);
    }

    public void put(K key, V value) {
        // Check if key exists in Window Cache
        if (windowCache.containsKey(key)) {
            windowCache.updateAccessTime(key);
            return;
        }

        // Check if key exists in Main Cache
        if (mainCache.containsKey(key)) {
            mainCache.updateAccessTime(key);
            return;
        }

        // If key does not exist in either cache, add it to Window Cache
        windowCache.put(key, value);

        // If Window Cache is full, evict the least recently used item
        if (windowCache.isFull()) {
            windowCache.evict();
        }

        // If Main Cache is full, evict the item with the lowest frequency
        if (mainCache.isFull()) {
            mainCache.evictByFrequency();
        }
    }

    public V get(K key) {
        // Check if key exists in Window Cache
        V value = windowCache.get(key);
        if (value != null) {
            return value;
        }

        // Check if key exists in Main Cache
        value = mainCache.get(key);
        if (value != null) {
            return value;
        }

        return null;
    }

    // ...
}

W-TinyLFU 算法的优点:

空间复杂度低：W-TinyLFU 算法只需要使用一个 bitmap 和一个计数器来记录数据项的访问频率，因此空间复杂度较低。
性能优良：W-TinyLFU 算法可以提供与 LFU 算法相近的缓存命中率。
时间窗口大小不敏感：W-TinyLFU 算法的性能不依赖于时间窗口的大小。
W-TinyLFU 算法的缺点:
实现复杂度较高：W-TinyLFU 算法的实现复杂度比 LRU 算法和 TinyLFU 算法要高。

W-TinyLFU 算法的应用场景:

W-TinyLFU 算法常用于对空间复杂度和缓存命中率要求都较高的场景，例如：

Web 缓存：Web 缓存中存储的通常是静态数据，例如图片、CSS 和 JavaScript 文件。这些数据的访问频率通常是固定的，因此使用 W-TinyLFU 算法可以有效地提高缓存空间的利用率和缓存命中率。
数据库缓存：数据库缓存中存储的通常是经常访问的数据。这些数据的访问频率可能会随着时间的推移而变化，因此使用 W-TinyLFU 算法可以保证经常使用的数据项不会被淘汰，并提高缓存命中率。