其他分享
首页 > 其他分享> > LRU和LFU的区别

LRU和LFU的区别

作者:互联网

c++多线程并发视频教材https://pan.baidu.com/s/1qLhfl83NeacIfR8QUJefmw

提取码:z9w1

对于web开发而言,缓存必不可少,也是提高性能最常用的方式。无论是浏览器缓存(如果是chrome浏览器,可以通过chrome:://cache查看),还是服务端的缓存(通过memcached或者redis等内存数据库)。缓存不仅可以加速用户的访问,同时也可以降低服务器的负载和压力。那么,了解常见的缓存淘汰算法的策略和原理就显得特别重要。

LRU和LFU的区别:

LRU是最近最少使用页面置换算法(Least Recently Used),也就是首先淘汰最长时间未被使用的页面!

LFU是最近最不常用页面置换算法(Least Frequently Used),也就是淘汰一定时期内被访问次数最少的页!

 

常见的缓存算法

LRU缓存

像浏览器的缓存策略、memcached的缓存策略都是使用LRU这个算法,LRU算法会将近期最不会访问的数据淘汰掉。LRU如此流行的原因是实现比较简单,而且对于实际问题也很实用,良好的运行时性能,命中率较高。下面谈谈如何实现LRU缓存:

 

 

LRU Cache具备的操作:

LRU的c++实现

LRU实现采用双向链表 + Map 来进行实现。这里采用双向链表的原因是:如果采用普通的单链表,则删除节点的时候需要从表头开始遍历查找,效率为O(n),采用双向链表可以直接改变节点的前驱的指针指向进行删除达到O(1)的效率。使用Map来保存节点的key、value值便于能在O(logN)的时间查找元素,对应get操作。

双链表节点的定义:

1 struct CacheNode {
2   int key;      // 键
3   int value;    // 值
4   CacheNode *pre, *next;  // 节点的前驱、后继指针
5   CacheNode(int k, int v) : key(k), value(v), pre(NULL), next(NULL) {}
6 };

对于LRUCache这个类而言,构造函数需要指定容量大小

1 LRUCache(int capacity)
2 {
3   size = capacity;      // 容量
4   head = NULL;          // 链表头指针
5   tail = NULL;          // 链表尾指针
6 }

双链表的节点删除操作:

 1 void remove(CacheNode *node)
 2 {
 3   if (node -> pre != NULL)
 4   {
 5     node -> pre -> next = node -> next;
 6   }
 7   else
 8   {
 9     head = node -> next;
10   }
11   if (node -> next != NULL)
12   {
13     node -> next -> pre = node -> pre;
14   }
15   else
16   {
17     tail = node -> pre;
18   }
19 }

将节点插入到头部的操作:

 1 void setHead(CacheNode *node)
 2 {
 3   node -> next = head;
 4   node -> pre = NULL;
 5  
 6   if (head != NULL)
 7   {
 8     head -> pre = node;
 9   }
10   head = node;
11   if (tail == NULL)
12   {
13     tail = head;
14   }
15 }

get(key)操作的实现比较简单,直接通过判断Map是否含有key值即可,如果查找到key,则返回对应的value,否则返回-1;

 1 int get(int key)
 2 {
 3   map<int, CacheNode *>::iterator it = mp.find(key);
 4   if (it != mp.end())
 5   {
 6     CacheNode *node = it -> second;
 7     remove(node);
 8     setHead(node);
 9     return node -> value;
10   }
11   else
12   {
13     return -1;
14   }
15 }

set(key, value)操作需要分情况判断。如果当前的key值对应的节点已经存在,则将这个节点取出来,并且删除节点所处的原有的位置,并在头部插入该节点;如果节点不存在节点中,这个时候需要在链表的头部插入新节点,插入新节点可能导致容量溢出,如果出现溢出的情况,则需要删除链表尾部的节点。

 1 void set(int key, int value)
 2 {
 3   map<int, CacheNode *>::iterator it = mp.find(key);
 4   if (it != mp.end())
 5   {
 6     CacheNode *node = it -> second;
 7     node -> value = value;
 8     remove(node);
 9     setHead(node);
10   }
11   else
12   {
13     CacheNode *newNode = new CacheNode(key, value);
14     if (mp.size() >= size)
15     {
16       map<int, CacheNode *>::iterator iter = mp.find(tail -> key);
17       remove(tail);
18       mp.erase(iter);
19     }
20     setHead(newNode);
21     mp[key] = newNode;
22   }
23 }

 

标签:node,链表,区别,value,LFU,LRU,key,节点
来源: https://www.cnblogs.com/yyjy-edu/p/15038937.html