LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 t，当须淘汰一个页面时，选择现有页面中其 t 值最大的，即最近最少使用的页面予以淘汰。
为什么要使用链表实现呢，因为这个页面不会很多，内存和资源开销都小
在计算机中，开销往往是需要考虑的，我们不希望占用过多的系统资源，动态路由小型网络使用RIP(Bellman-Ford Routing Algorithm)，大型网络设备用的就是OSPF(dijkstra)，当然也有很多方面的考虑，比如RIP配置和管理更简单，RIP为了避免出现网络延迟太高，也将路由器最大的允许跳数设为15
我们存储的时候就按照时间吧，末尾为刚刚使用的，淘汰前面的
然后我们来考虑下这个算法，保证我们不使用无关变量。这个cache是空的
进行一次请求需要查看我当前的cache里是否存在这个数据
1存在
存在就比较简单了，直接取出数据，页面数据不变，并把这个结点放在最后
2不存在
2.1cache满
把最靠前的页面用读取数据的数据覆盖，然后把它放到最后的cache
2.2cache不满
直接去读取数据，然后把他放在最后的页面
我需要维护的是一个编号(或者说地址)还有后结点，然后查询肯定是O(1)的，这是内部完成的，不需要我考虑(直接得到地址去取数据)
缺页中断都对应了一个硬件操作，就是去取这个数据
#include #include
structnode
{intid;struct node *next;
}* head, *tail, *p;voidPushBack()
{/*pre没有意义，仅需要多保留一个尾结点
p->pre = tail; //使pre指向前一个节点，循环可得到反向链表*/p->next =NULL;
tail->next =p;
tail=p;
}voidfun()
{struct node *q;
q=head;while (q->next !=NULL)
{if (q->next->id == p->id)//不缺页
{
PushBack();
p= q->next;
q->next = p->next;free(p);return; //执行完全部操作停掉
}
q= q->next;
}
printf("发生缺页中断 %d\n",p->id);
PushBack();
p= head->next;
head->next = p->next;free(p);
}intmain()
{intsum, n, i;
sum= 0; //初始cache内没有数据
scanf("%d", &n); //读入页数
head = (struct node *)malloc(sizeof(structnode));
head->next =NULL;
tail=head;while (1)
{
p= (struct node *)malloc(sizeof(structnode));
scanf("%d", &p->id);if (p->id < 0)
{break;
}else{if (sum < n) //cache未满，放至后面
{
PushBack();
printf("发生缺页中断 %d\n",p->id);
sum+= 1; //并对cache+1
}else{
fun();
}
}
}return 0;
}
事后来看，我说pre没有意义是不对的，因为实际上并不是乱序的，往往我们先访问的到的会被继续访问，并不是一个完全的均摊复杂度。
所以应该记录pre进行倒序，有兴趣的可以实现一下，不过我还是觉得c++好写，但是内部肯定是更厉害的
c++实现就用list搞一下啊，把最近访问的放到最前面
#include#include
void fun(std::list&L,intx)
{for(std::list::iterator it=L.begin();it!=L.end();it++)
{if(*it==x)
{
L.push_front(x);
L.erase(it);return;
}
}
std::cout<
L.pop_back();
L.push_front(x);
}intmain()
{
std::listL;intsum, n, i,x;
sum= 0; //初始cache内没有数据
std::cin>>n; //读入页数
while (true)
{
scanf("%d", &x);if (x < 0)
{break;
}else{if (sum < n) //cache未满，放至后面
{
L.push_front(x);
std::cout<
sum+= 1; //并对cache+1
}else{
fun(L,x);
}
}
}return 0;
}
C++ list 因为内部就是双向链表
public classLRUCache{private intlimit;private HashMaphashMap;privateNode head;privateNode end;public LRUCache(intlimit)
{this.limit =limit;
hashMap= new HashMap();
}publicString get(String key){
Node node=hashMap.get(key);if(node ==null)return null;
refreshNode(node);returnnode.value;
}public voidput(String key,String value){
Node node=hashMap.get(key);if(node == null){if(hashMap.size()>=limit)
{
String oldKey=removeNode(head);
hashMap.remove(oldKey);
}
node= newNode(key,value);
addNode(node);
hashMap.put(key,node)
}else{
node.value=value;
refreshNode(node);
}
}public voidremove(String key){
Node node=hashMap.get(key);
removeNode(node);
hashMap.remove(key);
}private voidrefreshNode(Node node)
{if(node ==end)return;
removeNode(node);
addNode(node);
}publicString removeNode(Node node){if(node ==end)
end=end.pre;else if(node ==head)
head=head.next;else{
node.pre.next=node.next;
node.next.pre=node.pre;
}returnnode.key;
}public voidaddNode(Node node)
{if(end!=null)
{
end.next=node;
node.pre=end;
node.next= null;
}
end=node;if(head == null)
head=node;
}
}
Java实现(高并发线程安全使用ConcurrentHashMap
