c++实现lru lfu页面置换算法_C++ 一步一步写LRU

最新推荐文章于 2021-04-17 13:48:02 发布
最新推荐文章于 2021-04-17 13:48:02 发布
阅读量693 收藏 1
点赞数
文章标签： c++实现lru lfu页面置换算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35078410/article/details/112071269
版权
本文介绍了LRU（Least Recently Used）和LFU（Least Frequently Used）页面置换算法，详细阐述了LRU的工作原理和应用场景，并探讨了如何在C++中实现LRU，包括使用链表作为元素容器，以及对实现过程的优化建议。同时，文章提到LRU在操作系统、Android内存缓存和Redis中的应用，并提到了线程安全和数据结构优化等问题。
摘要由CSDN通过智能技术生成

什么是LRU

LRU(Least recently used)，它其实是一个Queue，当其中某个元素被使用时，就把该元素从从队列中重新拿回到队首，如此进行下去，最不经常被访问的元素，就很容易被剔除队列。以此，LRU中保存的始终都是最常被访问的元素了，淘汰的都是不常访问的元素。
LRU的兄弟还有LFU (Least frequently used)，原理和LRU恰好相反。

什么场景使用LRU

LRU是最常接触的缓存策略，想想操作系统中学习的页面置换算法。LRU就是常用的页面置换算法之一，操作系统的内存就是通过LRU的策略进行页的换出和换入，LRU算法是比较接近理想的一种页面置换算法，这种算法既充分利用了内存中页面调用的历史信息，又正确反映了程序的局部问题。
LRU也同样在工程代码中经常出现，使用的场景也经常为淘汰算法，缓存策略等等。例如Android使用LRU策略进行实现内存缓存，Redis中也有一个近似LRU的算法，感兴趣的小伙伴可以去深挖一下，这里就不多做剖析了。

如何实现一个LRU

1. LRU中保存的元素

template<typename K, typename V>
class Entry final
{
public:
    K key;
    V value;
};

保存的元素最好使用模板，K用来索引元素，V为真正的元素类型

2. LRU中使用链表

template<typename K, typename V>
using Iter = typename std::list<Entry<K, V>>::iterator;

template<typename K, typename V>
class List final
{
public:
    List() : capacity_(0) {}

    ~List()
    {
        lst_.clear();
    }

    uint get_capacity() const
    {
        return capacity_;
    }

    Iter<K, V> push_front(Entry<K, V> &entry)
    {
        ++capacity_;
        return lst_.insert(lst_.begin(), entry);
    }

    Iter<K, V> move_to_front(Iter<K, V> &it)
    {
        auto v = (*it);
        lst_.erase(it);
        return lst_.insert(lst_.begin(), v);
    }

    bool remove(Iter<K, V> &it)
    {
        if (lst_.size() > 0 && capacity_ > 0)
        {
            --capacity_;
            lst_.erase(it);
            return true;
        }

        return false;
    }

    Iter<K, V> back()
    {
        if (lst_.size() > 0 && capacity_ > 0)
            return (--lst_.end());

        return lst_.end();
    }

    bool is_end(Iter<K, V> it) const
    {
        return it != lst_.end();
    }

private:
    uint capacity_;
    list<Entry<K, V>> lst_;
};

在LRU里要使用这个链表的目的是什么呢？答案是保存元素的容器。这个容器的实现有很多种，我看到过很多种不同的容易来管理元素的（vector, unordered_map等），追究其根本，核心功能就是使用这个数据结构进行元素位置的调整。因为当元素被访问时，整个LRU需要将这个元素重新放置在队首。为满足这个需求，大家可以分析一下是不是链表的操作要略强一些，还有没有更优的数据结构在存放（可以牺牲空间）。

3. LRU的实现

template<typename K, typename V>
class LRUQueue final
{
public:
	// 构造函数，默认容量1024
    explicit LRUQueue(uint fixedCapacity = 1024)
            : fixed_capacity_(fixedCapacity)
    {}
	// 默认析够
    ~LRUQueue() = default;

	// 插入元素
    void insert(const K &key, const V &value);

	// 获取元素，并调整元素位置
    V get(const K &key);

	// 从LRU中手动移除
    bool remove(const K &key);

private:
	// 从list和map中移除元素
    inline void delete_(Iter<K, V> &it);

private:
    uint fixed_capacity_;
    std::unordered_map<K, Iter<K, V>> lru_map_;
    List<K, V> lru_list_;
};

简单描述一下实现原理

  • LRUQueue`中成员主要两个
    • List<K, V> lru_list_: LRU中缓存元素的列表
    • std::unordered_map<uint, Iter<K, V>> lru_map_;这个Map保存LRU元素的key和在List中Iterator，方便在List中快速定位和进行操作。
  • 整个LRUQueue类包含如下几个成员方法：
    • void insert(const K &key, const V &value) : 向LRU中插入元素
    • V get(const K &key): 从LRU中获取Key的元素
    • bool remove(const K &key): 从LRU中手动移除元素，返回true表示元素在LRU中并成功移除，否则返回false。这个方法在LRU的实现中可有可无，根据需求自行使用。

LRU优化

上述的LRU结构是否足够优雅，效率是否达到了最佳，我们来一起探讨一下。优化主要方向围绕时间效率展开，针对插入insert和读取get进行讨论：

分析LRUQueue::get()

V LRUQueue::get(const K &key)
{
    auto it = lru_map_.find(key);
    if (it == lru_map_.end())
        return V();

    auto new_it = lru_list_.move_to_front(it->second);
    lru_map_[key] = new_it;

    return new_it->value;
}

Iter<K, V> List::move_to_front(Iter<K, V> &it)
{
    lst_.erase(it);
    return lst_.insert(lst_.begin(), (*it));
}

这个方法中有两个主要的问题：

  1. 返回的类型为模板V，这就要求实际的类具有拷贝构造函数，如果key不在LRU中，返回的V()还要求具备构造函数;
  2. 存储元素的容器list在将元素重新插入到队首时，做了两步操作先erase元素，再将元素insert到队首，有没有简单的方法来进行迁移。

针对这两个问题，分别给出修复的方案：

  1. 针对返回V时要求具备构造和拷贝构造的问题，有两个解决方案，一个是返回List的Interator,另一个是容器中保存std::shared_ptr<V>
  2. 因为list没有方法直接完成将某个元素重新放到队首的方法，只能先erase再insert。并且整个操作的过程还要使用Interator。优化的方法，可以使用Linux底层的数据结构list_head或者自己写一个简单的保存了头指针的双向链表数据结构。

分析LRUQueue::insert()

void insert(const K &key, const V &value)
{
    auto it = lru_map_.find(key);
    if (it != lru_map_.end())
    {
        lru_map_[key] = lru_list_.move_to_front(it->second);
        return;
    }

    auto entry = Entry<K, V>{key, value};
    lru_map_[key] = lru_list_.push_front(entry);
    
    if (lru_list_.get_capacity() > fixed_capacity_)
    {
        auto end = lru_list_.back();
        delete_(end);
    }
}

插入LRU的问题和解决：

  1. 插入的操作需要根据业务需求进行设计。例如，重复插入是否报错，应不应该更新元素;
  2. Map一定要保存List的Interator吗，是否可以保存双向链表的指针本身;
  3. 当超过容量限制时，操作删除还是基于Interator进行，可以优化成指针的直接操作,或者彻底废弃删除接口

其他问题

  1. 整个LRU不是线程安全的，希望线程安全的话，需要LRU中添加锁
  2. Entry数据结构不需要再重复保存key值.

最终实现

#ifndef MYUTILS_LRUQUEUE_H
#define MYUTILS_LRUQUEUE_H

#include <string>
#include <map>
#include <list>
#include <unordered_map>
#include <memory>

#include "DisableCopyAndAssign.h"

using std::list;
using std::string;

template<typename K, typename V>
class Entry
{
public:
    typedef std::shared_ptr<V> ValuePtr;
    explicit Entry(K key, V *ptr) : key(key), value(ptr) {}

    ~Entry()
    {
        next = nullptr;
        pre = nullptr;
    }

    K key;
    ValuePtr value;
    Entry *next = nullptr;
    Entry *pre = nullptr;
};

template<typename K, typename V>
class List final
{
public:
    typedef Entry<K, V> EntryType;

    // 禁用拷贝构造和等号运算符
    DISABLE_COPY_AND_ASSIGN(List);

    List() = default;

    ~List()
    {
        clear();
    }

    void clear()
    {
        EntryType *temp;
        auto ptr = first_->next;
        while (ptr != last_)
        {
            temp = ptr->next;
            first_->next = temp;
            temp->pre = first_;
            delete ptr;
            ptr = temp;
        }

        delete ptr;
        size_ = 0;
        first_ = nullptr;
        last_ = nullptr;
    }

    template <class...Args>
    EntryType *emplace_front(Args&&... args)
    {
        auto entry = new EntryType(std::forward<Args>(args)...);
        return emplace_front(entry);
    }

    EntryType *emplace_front(EntryType *entry)
    {
        if(size_ == 0)
        {
            first_ = entry;
            last_ = entry;
            first_->next = last_;
            last_->pre = first_;
            size_ = 1;
        }
        else
        {
            entry->pre = last_;
            entry->next = first_;
            first_->pre = entry;
            last_->pre = entry;
            first_ = entry;
            ++size_;
        }
        return entry;
    }

    template <class...Args>
    EntryType *emplace_back(Args&&... args)
    {
        auto entry = new EntryType(std::forward<Args>(args)...);
        return emplace_back(entry);
    }

    EntryType *emplace_back(EntryType *entry)
    {
        if(size_ == 0)
        {
            first_ = entry;
            last_ = entry;
            first_->next = last_;
            last_->pre = first_;
            size_ = 1;
        }
        else
        {
            last_->next = entry;
            entry->pre = last_;
            last_ = entry;
            first_->pre = last_;
            size_++;
        }
    }

    K pop_front()
    {
        auto ptr = first_;
        first_ = first_->next;
        auto key = ptr->key;
        delete ptr;
        if(!first_)
            last_ = nullptr;
        --size_;
        return key;
    }

    K pop_back()
    {
        auto ptr = last_;
        last_ = last_->pre;
        auto key = ptr->key;
        delete ptr;
        if(!last_)
            first_ = nullptr;
        --size_;
        return key;
    }


    void move_to_front(EntryType *entry)
    {
        if(!entry || empty() || size_ == 1 || entry == first_)
             return;
        if(entry == last_)
            entry->pre->next = nullptr;
        else
        {
            entry->pre->next = entry->next;
            entry->next->pre = entry->pre;
        }
        // 下面emplace_front会重新将计数+1
        --size_;
        emplace_front(entry);
    }

    EntryType *front() const
    {
        return first_;
    }

    EntryType *back() const
    {
        return last_;
    }

    uint64_t size() const
    {
        return size_;
    }

    bool empty() const
    {
        return size_ == 0;
    }

    template <typename FUNCTION>
    void for_each(FUNCTION &&func)
    {
        auto ptr = first_;
        while (ptr)
        {
            func(ptr->value);
            ptr = ptr->next;
        }
    }

private:
    uint64_t size_ = 0;
    EntryType *first_ = nullptr;
    EntryType *last_ = nullptr;
};

template<typename K, typename V>
class LRUQueue final
{
public:
    typedef std::shared_ptr<V> ValuePtr;

    // 禁用拷贝构造和等号运算符
    DISABLE_COPY_AND_ASSIGN(LRUQueue);

    explicit LRUQueue(uint fixedCapacity = 1024) : fixed_capacity_(fixedCapacity) {}

    ~LRUQueue() = default;

    template <class...Args>
    void insert(const K &key, Args&&... args)
    {
        auto it = lru_map_.find(key);
        if (it != lru_map_.end())
        {
            // 插入重复元素，只更新位置
            lru_list_.move_to_front(it->second);
            return;
        }

        auto entry = new Entry<K, V>(key, new V(std::forward<Args>(args)...));
        lru_map_[key] = lru_list_.emplace_front(entry);

        if (lru_list_.size() > fixed_capacity_)
            lru_map_.erase(lru_list_.pop_back());
    }

    ValuePtr get(const K &key)
    {
        auto it = lru_map_.find(key);
        if (it == lru_map_.end())
            return nullptr;

        lru_list_.move_to_front(it->second);
        return it->second->value;
    }

private:
    uint fixed_capacity_;
    std::unordered_map<K, Entry<K, V> *> lru_map_;
    List<K, V> lru_list_;
};

#endif

链接：github仓库地址，欢迎点星

阿Nel
关注
LRU页面置换算法C++代码
IT_Quanwudi的博客
08-17 2976
LRU页面置换算法C++代码 常见的缓存算法： LRU：(least recently used) 最近最少使用，思想是如果一个数据刚被访问过，那么将来被访问的几率也更高 LFU：(least frequently used) 最少经常使用，思想是如果一个数据很久不被访问，那么将来被访问的几率也不大 FIFO：(first in first out) 先进先出，思想是如果一个数据最先进入缓...
页面置换算法——LRU的简易实现(C++)
szy0321的博客
05-18 1710
LRU 最近最久未使⽤的置换算法（LRU）：最近最久未使用（LRU）的置换算法的基本思路是，发生缺页时，选择最长时间没有被访问的页面进行置换，也就是说，该算法假设已经很久没有使用的页面很有可能在未来较长的⼀段时间内仍然不会被使用。 图解： 最后一步因为1号页面是「过去时间段里最久没有被访问的」， 所以把1号页面换出到磁盘，然后把3号页面换入到内存。 代码简易实现 #include<iostream> #include<list> #include<map> using
用C++实现LRU页面置换算法
06-03
使用LRU算法实现页面置换算法。LRU算法基于一种假设，长期不使用的数据，在未来的使用性也不大。因此，当数据占用内存达到一定的阙值时，我们要移除最近最少使用的数据。LRU算法中，使用了一种有趣的数据结构，叫做哈希链表。 我们都知道，哈希表是由若干个Key-Value所组成，在逻辑上，这些Key-Value是无所谓排列顺序的。 在哈希链表中，这些Key-Value不再是彼此无关的存在，而是被一个链条串联起来，每一个key-Value都有它的前驱和后继Key-value，就像双向链表中的节点一样。这样一来，无序的哈希表拥有了固定的排列顺序。
页面置换算法（OPT、FIFO、LRU）实现--C++版本
09-15
该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法，包括先进先出（FIFO）、最佳置换算法（OPT）、最久最近未使用算法（LRU）。 具体实现功能有： 1、建立相应的数据结构 2、在屏幕上显示页面的状况 3、时间的流逝可用下面几种方法模拟：按键盘，每按一次可认为过一个时间单位; 4、将一批页的置换情况存入磁盘文件，以后可以读出并重放; 5、计算页面的缺页次数、缺页后的页面置换次数 6、支持算法：FIFO、LRU、最佳置换算法。
操作系统实验报告 用C++实现页面置换算法，LRU与FCFS
12-02
操作系统实验报告，用C++实现 最近最久未使用LRU,先来先服务页面置换算法FIFO
借助C++实现LRU页面置换算法
zhongziQ的博客
04-17 570
### 什么是LRU页面置换算法 LRU(Least Recently Used)，是页面置换算法的一种，它的主要思想是当用于缓存页面的地址块已满时，选择最久未使用的页面删除，然后用将新请求的页面加入缓存。 例如：请求为 {1,2, 0, 3, 0, 1, 2, 3, 2}，缓存大小为3，那么 1 2 0 3 0 1 2 3 2 地址块1 1 1 1 3 3 3 2 2 2 地址块..
FIFO，LRU，LFU 的三种页面置换算法的C++实现
最新发布
04-09
OS操作系统上机题 FIFO，LRU，LFU 的三种页面置换算法的C++实现 {3,2,1,3,2,5,2,3,6,2,1,4,2} 为本实验例子的页面走向 copy直接可运行 提供简单可视化菜单 三种页面置换算法可供选择 注释详细，初学者亦可看懂
C++实现FIFO、LRU、LFU页面置换算法
"该资源提供的是一个C++实现的页面置换算法程序，涵盖了FIFO（先进先出）、LRU（最近最少使用）和LFU（最不经常使用）三种策略。程序包含一个简单的可视化菜单供用户选择算法，并使用了一个具体的页面走向序列（{3,2...
操作系统页面置换算法实现，fifo、lfu、lru、opt，界面由MFC实现
03-28
本项目实现了一个模拟器，用于演示和比较四种不同的页面置换算法：FIFO（先进先出）、LFU（最不常用）、LRU（最近最少使用）以及OPT（最佳页面置换）。界面使用Microsoft Foundation Class (MFC)库来创建，使得用户...
操作系统 课程设计 页面置换算法FIFO和 LRU
08-14
本课程设计项目专注于两种常见的页面置换算法：FIFO（先进先出）和LRU（最近最少使用）。这两种算法都是为了在主存空间不足时决定哪些页面应该被换出到磁盘，以便腾出空间加载新的页面。 **FIFO页面置换算法**： ...
页面置换算法（OPT、FIFO、LRU）实现--C++版本-页面置换算法（Optimal、FIFO、LRU）
12-18
该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法，包括先进先出（FIFO）、最佳置换算法（OPT）、最久最近未使用算法（LRU）。 具体实现功能有： 1、建立相应的数据结构 2、在屏幕上显示页面的状况 3、时间的流逝可用下面几种方法模拟：按键盘，每按一次可认为过一个时间单位; 4、将一批页的置换情况存入磁盘文件，以后可以读出并重放; 5、计算页面的缺页次数、缺页后的页面置换次数 6、支持算法：FIFO、LRU、最佳置换算法。 操作系统常见三大页面置换算法。Optimal、FIFO、LRU。在其中的测试用例才有了《计算机操作系统》第三版，书中的例子作为测试。
LRU 页面置换算法 最近最久未使用 源代码 c/c++
01-08
完整的算法源代码 随即输入任意数 算出缺页次数和缺页率
fifo&lru;页面置换算法c++实现
11-27
fifo&lru;页面置换算法c++实现，从trace.txt文档中读入置换页面序号
操作系统LRU页面置换算法 C语言程序
05-25
操作系统LRU页面置换算法 C语言程序 数组实现 简单，清晰且实用，
操作系统 C++ 页面置换算法（含实验报告）有opt，LRU，先进先出，时钟算法，改进的时钟算法等所有算法
10-04
本实验使用一下算法 使用rand（）函数随机产生页面号，用数组装入页面号，模拟页面调入内存中发生页面置换的过程。 整个过程，都是使用数组来实现每个算法，模拟队列，模拟堆栈的功能，实现每一个置换算法。 页面置换算法 最佳置换算法（OPT）：选择永不使用或是在最长时间内不再被访问（即距现在最长时间才会被访问）的页面淘汰出内存。用于算法评价参照。 随机置换算法 （S）：产生一个取值范围在0和N-1之间的随机数，该随机数即可表示应被淘汰出内存的页面。 先进先出置换算法（FIFO）：选择最先进入内存即在内存驻留时间最久的页面换出到外存。 最近最久未使用置换算法（LRU）: 以“最近的过去”作为“最近的将
java 最少使用(lru)置换算法_缓存淘汰算法LRU和LFU
weixin_39721924的博客
11-23 348
前言LRU算法和LFU算法是属于页面置换的一种算法，或者更通俗的说，就是缓存如何淘汰的一种策略。我们通常在设计一个系统的时候，由于数据库的读取速度远小于内存的读取速度，所以为了加快读取速度，会将一部分数据放到内存中，称为缓存。但是内存容量是有限的，当你要缓存的数据超出容量，就得有部分数据删除，这时候哪些数据删除，哪些数据保留，就是LRU算法和LFU算法要干的事。什么是LRU算法LRU算法，全称Le...
DML操作数据--天冷加衣
weixin_44561963的博客
11-22 228
DML的增删改操作一、添加数据1.基本语法二、删除数据1.条件删除数据2.删除表中所有数据三、修改数据1.条件修改数据 一、添加数据 1.基本语法 insert into 表名(列名1,列名2,...列名n) values (值1,值2,...值n) 简化 insert into 表名 values (值1,值2,...值n) --需要写全所有列的值 --除了数字，其他类型值需要加引号（单双都可） 二、删除数据 1.条件删除数据 delete from 表名 where 条件 2.删除表中所有数.
LRU页面置换算法的C++模拟实现
Monster7559的博客
08-12 1861
#include<iostream> #include<vector> #include<string> #include<map> #include<algorithm> #include<hash_map> #include<list> #include<assert.h> using names...
Java千万级数据插入开启事务_LRU和LFU ; redis事务
weixin_39636707的博客
11-20 132
LRU和LFU对于web开发而言，缓存必不可少，也是提高性能最常用的方式。无论是浏览器缓存(如果是chrome浏览器，可以通过chrome:://cache查看)，还是服务端的缓存(通过memcached或者redis等内存数据库)。缓存不仅可以加速用户的访问，同时也可以降低服务器的负载和压力。那么，了解常见的缓存淘汰算法的策略和原理就显得特别重要。常见的缓存算法LRU (Least r...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值