有人从网络读数据，有人从磁盘读数据，机智的人懂得合理利用缓存加速数据的读取效率，提升程序的性能，搏得上司的赏识，赢得白富美的青睐，进一步走向人生巅峰~

LRU假说

        LRU缓存（Least Recently Used Cache）即最近最少使用缓存算法，是一种常用的缓存淘汰策略，它基于这样一个假设：

如果数据最近被访问过，那么它在未来被访问的可能性也更高。

        因此，当缓存空间不足时，LRU缓存会优先移除最长时间未被访问的数据项。        

LRU是怎么干活的

新访问的数据添加到缓存

        当一个数据项被访问时，它会被添加到缓存中。如果该数据项已经在缓存中，它会被更新，并且移动到缓存的最前面，表示最近被访问过。

缓存满时移除最老的数据

        如果缓存已满（达到预设的容量限制），最久未被访问的数据项（位于缓存的最后面）会被移除，以便为新的数据项腾出空间。

维护访问顺序

        缓存需要维护数据项的访问顺序，以便快速确定哪些数据项是最近被访问的，哪些是最久未被访问的。

为了有效地实现LRU缓存，通常需要以下两种数据结构：
        双向链表：用于维护数据项的访问顺序。最近访问的数据项位于链表一头，最久未访问的数据项位于链表另一头。当数据项被访问时，它会被移动到链表最近访问那一头。当需要移除数据项时，最久未访问的末尾数据项会被移除。
        哈希表：用于存储键和指向双向链表中相应节点的指针，以便快速定位缓存中的数据项。这样可以在O(1)时间复杂度内访问缓存项。

LRU的简单示例

如下是一个简单的LRU实现：

#include <iostream>
#include <list>
#include <string>
#include <unordered_map>
#include <vector>

using namespace std;

template <typename K, typename V>
class LRUCache {
public:
    LRUCache(int capacity) {
        cap = capacity;
    }

    V get(const K& key) {
        auto it = hash.find(key);
        if (it == hash.end()) {
            return V();
        }

        auto val = it->second->second;
        put(key, val);
        return val;
    }

    void put(const K& key, const V& value) {
        auto it = hash.find(key);
        if (it == hash.end()) {
            if (hash.size() >= cap) {
                auto d_it = data_list.begin();
                auto h_it = d_it->first;
                data_list.erase(d_it);
                hash.erase(h_it);
            }
        } else {
            auto d_it = it->second;
            data_list.erase(d_it);
            hash.erase(it);
        }

        data_list.emplace_back(key, value);
        hash[key] = --data_list.end();
    }

private:
    int cap;
    list<pair<K, V> > data_list;

    using LIST_IT = typename list<pair<K, V> >::iterator;
    unordered_map<K, LIST_IT> hash;
};

int main() {
    LRUCache<int, int> lru(2);

    vector<pair<string, vector<int> > > test_case = {
        {"put", {1, 1}},
        {"put", {2, 2}},
        {"get", {1}},
        {"put", {3, 3}},
        {"get", {2}},
        {"put", {4, 4}},
        {"get", {1}},
        {"get", {3}},
        {"get", {4}},
    };

    for (const auto& [opt, param] : test_case) {
        if (opt == "get") {
            auto val = lru.get(param.front());
            cout << val << endl;
        } else {
            lru.put(param.front(), param.back());
        }
    }

    return 0;
}

运行测试用例可以得到如下结果：

code % g++ lru.cpp -std=c++17
code % ./a.out       
1
0
0
3
4
code % 

        如上，实现一个LRU的代码量并不算多，并且简单易懂，性能也很不错，毕竟时间复杂度为O(1)。但LRU也有其缺点，例如它没有考虑数据的访问频率。这可能会导致一些不经常使用的数据被缓存，而一些经常使用的数据被淘汰。

LRU的改进-LFU

        LFU（Least Frequently Used），即最少使用频率缓存，考虑到访问频率，而不是最近一次访问时间。其可以与LRU结合，形成其他变种，以更好地适应不同的数据访问模式。

LFU的简单示例

        例如，可以通过给LRU缓存数据项加上访问频率，当缓存满需要淘汰时，取尾部的数据选一个访问频次最低的来淘汰：

#include <iostream>
#include <list>
#include <string>
#include <unordered_map>
#include <vector>

using namespace std;

template <typename K, typename V>
class LRUCache {
public:
    LRUCache(int capacity) {
        cap = capacity;
    }

    V get(const K& key) {
        auto it = hash.find(key);
        if (it == hash.end()) {
            return V();
        }

        const auto& data_tuple = *(it->second);
        auto val = std::get<1>(data_tuple);
        auto cnt = std::get<2>(data_tuple);
        put(key, val, cnt + 1);
        return val;
    }

    void put(const K& key, const V& value, int cnt = 1) {
        auto it = hash.find(key);
        if (it == hash.end()) {
            if (hash.size() >= cap) {
                remove_one_elem();
            }
        } else {
            auto d_it = it->second;
            data_list.erase(d_it);
            hash.erase(it);
        }

        data_list.emplace_back(key, value, cnt);
        hash[key] = --data_list.end();
    }

private:
    void remove_one_elem() {
        auto need_rm = data_list.begin();
        auto it = need_rm;
        for (int i = 1; i < 3 && it != data_list.end(); ++i, ++it) {
            if (std::get<2>(*it) < std::get<2>(*need_rm)) {
                need_rm = it;
            }
        }

        hash.erase(std::get<0>(*need_rm));
        data_list.erase(need_rm);
    }

private:
    int cap;
    list<tuple<K, V, int> > data_list;

    using LIST_IT = typename list<tuple<K, V, int> >::iterator;
    unordered_map<K, LIST_IT> hash;
};

int main() {
    LRUCache<int, int> lru(2);

    vector<pair<string, vector<int> > > test_case = {
        {"put", {1, 1}},
        {"put", {2, 2}},
        {"get", {1}},
        {"put", {3, 3}},
        {"get", {2}},
        {"put", {4, 4}},
        {"get", {1}},
        {"get", {3}},
        {"get", {4}},
    };

    for (const auto& [opt, param] : test_case) {
        if (opt == "get") {
            auto val = lru.get(param.front());
            cout << val << endl;
        } else {
            lru.put(param.front(), param.back());
        }
    }

    return 0;
}

运行测试用例可以得到如下结果：

code % g++ lfu.cpp -std=c++17
code % ./a.out       
1
0
1
0
4
code % 

        与LRU示例的差异点在于，当缓存满时，LFU为从最近未使用的一头，挑选一个访问频次最小的元素进行淘汰。值得注意的是，挑选最少频次并不需要遍历所有的数据，而是针对具体的业务场景，设定一个合适的值即可。

        虽然LRU开销很小，时间复杂度又是O(1)，但毕竟每次访问都需要调整链表，对于一些性能要求高的场景，负担还是有点重的，实际的使用场景中，又会根据具体的业务场景，做一些响应的改变。

衍生一下

Clock算法

        Clock算法是一种用于页面置换的缓存淘汰策略，它是LRU算法的一种近似实现，旨在降低实现LRU的开销。Clock算法有时也被称为Second-Chance算法，因为它给了每个页面一个“第二次机会”来避免被置换。

Clock是怎么干活的

        Clock算法维护一个循环链表：所有的页面都被组织成一个循环链表（或称为时钟结构），每个页面都有一个关联的访问位（通常是一个标志位），用于表示该页面自上次检查以来是否被访问过。

        使用指针指向链表中的一个页面：有一个指针（称为时钟指针）指向循环链表中的某个页面。

        维护访问位：当一个页面被访问时，其访问位被设置为1，表示该页面最近被使用过。

        缓存满时检查访问位：当有新需要加载到缓存中，但缓存已满，算法会检查当前时钟指针指向的页面的访问位。如果访问位为1，则将其清零（给予第二次机会），并将时钟指针移动到下一个页面。如果访问位为0，则选择该页面进行置换。

        Clock算法的优点是实现简单，开销较低，因为它不需要像真正的LRU算法那样在每次页面访问时都对链表进行调整。它只需要在页面置换时检查和更新访问位。这使得Clock算法特别适合于大规模的缓存系统，如操作系统的页面缓存。

        Clock算法的缺点是它不是完全精确的LRU实现，因为它可能会保留一些不太常用的页面（如果它们在时钟指针到达之前刚好被访问过）。然而，对于许多实际应用来说，Clock算法提供了一个很好的折中方案，既保留了LRU的大部分优点，又显著降低了实现的复杂性和开销。