java实现lru算法

❶ 如何用java实现fifo页面置换算法

[fifo.rar] - 操作系统中内存页面的先进先出的替换算法fifo
[先进先出页面算法程序.rar] - 分别实现最佳置换算法(optimal)、先进先出(fifo)页面置换算法和最近最久未使用（LRU）置换算法，并给出各算法缺页次数和缺页率。
[0022.rar] - 模拟分页式虚拟存储管理中硬件的地址转换和缺页中断，以及选择页面调度算法处理缺页中断
[Change.rar] - 用java实现操作系统的页面置换 其中包括 最佳置换算法(Optimal)、先进先出算法（First-in, First-out） 、最近最久不用的页面置换算法（LeastRecently Used Replacement）三种算法的实现
[M_Management.rar] - 操作系统中内存管理页面置换算法的模拟程序，采用的是LRU置换算法
[detail_of_44b0x_TCPIP.rar] - TCPIP 程序包加载到44b0x 的ADS1.2工程文件的说明书。说名了加载过程的细节和如何处理演示程序和代码。演示代码已经上传，大家可以搜索
[.rar] - java操作系统页面置换算法： （1）进先出的算法（fifo） （2）最近最少使用的算法（LRU） （3）最佳淘汰算法(OPT) （4）最少访问页面算法(LFU) （注：由本人改成改进型Clock算法） （5）最近最不经常使用算法(NUR)

❷ LinkedHashMap实现LRU - 附重点源码解析

最近接触 LRU(Least Recently Used) ，即最近最少使用，也银空称 淘汰算法 ，在JDK中LinkedHashMap有相关实现，下面针对 LRU及LinkedHashMap的LRU实现 进行详细讲解

有些数据需要缓存在内存中，以便高效查询。但是当缓存的数据量很大，并且某一时间段只有某小部分缓存数据被频繁使用(称之为热点数据)，而其他缓存数据暂时没有访问，这时就需要LRU策略对热点数据进锋裂瞎行保留，对非热点数据进行及时下线，保证缓存空间健康源芦。
应用场景 : 商城分时段商品秒杀

创建LRULinkedHashMap继承LinkedHashMap并重写removeEldestEntry方法，该方法返回的boolean代表是否删除最早使用/存放的Entry。

LinkedHashMap 继承自 HashMap ，HashMap采用数组加链表的结构存储数据，存储节点为HashMap.Node，分别存放hash值，key，value，以及指向下一个Node节点的next指针，链表结构是单项链表，HashMap并没有维护有序性。

LinkedHashMap 继承了HashMap，也是采用了数据加链表的结构，不同的是LinkedHashMap的存储节点(Entry)继承自HashMap.Node， 多维护了before和after指针，用来指向上一个和下一个节点，实现双向链表 。这个双向链表就可以实现Map有序性(access-order:访问顺序/insertion-order插入顺序， 默认是insertion-order )。

下面是设置 LinkedHashMap 为 访问顺序 时的示意图。

❸ LRU算法 O(1)时间复杂度

实现缓粗LRU算法，查找删除时间复杂度都为O(1)
LRU Cache是一个Cache置换算法，含义是“最近最少使用”，当Cache满（没有空闲的cache块）时，扰缺镇把满足“最近最少使用”的数据从Cache中置换出去，并且保证Cache中第一个数据是最近刚刚访问的

实现思路
利用hashmap加链扮燃表来实现这个原理
链表元素node由两个元素构成（key-value），在hashmap中存入node的key值，以及node；hashmap的构成为<Integer,Node>

为保证每次查找为O(1)并要判断双向链表里面是否含有元素，所以要将node设为两个值，key和value，其中node的key与map的值相同，当hashmap中存在key的时候，则双向链表中也存在key。利用这个特质，能完成查找删除都为O(1)

将最小使用的元素删除，核心就是每次插入的时候，都插入到链表的头结点；每次get一个元素时候，将get的那个元素删除，然后将元素插入到头结点

❹ java lru 算缺页率

LRU按最近最少使用原则淘汰，即将a,c,d,e...b,v,d一次在cache中存取如果cache中不存在则淘汰最久没被使用的然后加入要使用的。比如说（暂且用李宏【】表示cache）：加入a(缺页+)【a】，加入c【c,a】(缺页+)，加入d【d,c,a】(缺页+)，加入e【e,d,c,a】(缺页敏此+),加入t【t,e,d,c,a】这个时候cache空间用完，之后应用LRU淘汰机制，加入y【y,t,e,d,c】(缺页+，a最久未用被淘汰掉哪拿册)，加入d(catche中有d,不产生缺页)【d,y,t,e,c】加入f【f,d,y,t,e】(缺页+) 。。。之后一次进行。大概就这样一个思路最后缺页率就是缺页中断次数相加之和/序列总数。

❺ 用java语言实现LRU算法和FIFO算法。急急急！！！！！！！

您好，网络贴吧专家团很高兴能够回答您的问题。您的采纳是我们前进的动力。
public class LRU {

private int theArray[];
private int back; //定义队尾
private int currentSize; //队列中存放元素个数
private int maxSize=5; //队列中能存放元素的个数

public LRU(){
theArray=new int[maxSize];
back=0;
currentSize=0;
}
public void queue(int a[]){
for(int i=0;i<a.length;i++){
enQueue(a[i]);
}
}

public void enQueue(int x){ //入队
beUsed(x); //先判断是否已存在该页号，若存在，删除
if(currentSize<maxSize){
theArray[back]=x;
back++;
currentSize++;
}else if(currentSize==maxSize){ //满了
for(int i=0;i<maxSize-1;i++){
theArray[i]=theArray[i+1];
}
theArray[maxSize-1]=x;
}
for(int i=0;i<currentSize;i++){
System.out.print(theArray[i]);
}
System.out.println();
}
public void beUsed(int x){ //判断是否已存在该页号,若存在，删除已有的
for(int i=0;i<currentSize;i++){
if(theArray[i]==x){
for(int j=i;j<currentSize-1;j++){
theArray[j]=theArray[j+1];
}
currentSize--;
back--;
}
}
}
public static void main(String[] args) {
LRU lru=new LRU();
int a[]={4,7,0,7,1,0,1,2,1,2,6};
lru.queue(a);
}

}

❻ lru的算法是什么

lru的算法是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 t，当须淘汰一个页面时，选择现有页面中其 t 值最大的，即最近最少使用的页面予以淘汰。

对于虚拟页式存储，内外存信息的替换是以页面为单位进行的——当需要一个放在外存的页面时，把它调入内存，同时为了保持原有空间的大小，还要把一个内种调动越少，进程执行的效率也就越高。

硬件支持

LRU置换算法虽然是一种比较好的算法，但要求系统有较多的支持硬件。为了了解一个进程在内存中的各个页面各有多少时间未被进程访问，以及如何快速地知道哪一页是最近最久未使用的页面，须有两类硬件之一的支持：寄存器或栈。

寄存器

为了记录某进程在内存中各页的使用情况，须为每个在内存中的页面配置一个移位寄存器，可表示为：

R = Rn-1 Rn-2 Rn-3…R2 R1 R0。

❼ Java程序设计

I am sorry; in China; please speak Chinese;谢谢；我之所以写了句英语只是因为担心你是外国人；哎；

❽ java中LinkedHashMap的LRU算法,为什么多次访问其实并未改变元素的实际排序

要这样才行！！
Map hashMap = new LinkedHashMap<Integer, Integer>(16,(float) 0.75,true);

hashMap.get(2);是获取KEY为2的那一组，即（2，2）
二使用最多，所以排到最后 。
如果你要得到(3,3)就用hashMap.get(3). 这里面的3并不是map中的索引数值，而是你定义的KEY 。 你可以这样：
for (int i = 0; i < 6; i++) {
hashMap.put(i+"--", i);
}
即将KEY变为字符串，你获取数据的时候就必须用get("1--")这样的KEY

❾ Redis的缓存淘汰策略LRU与LFU

Redis缓存淘汰策略与Redis键的过期删除策略并不完全相同，前者是在Redis内存使用超过一定值的时候（一般这个值可以配置）使用的淘汰策略；而后者是通过定期删除+惰性删除两者结合的方式淘汰内存过期键的。
这里参照官方文档的解释重新叙述一遍过期删除策略：当某个key被设置了过期时间之后，客户端每次对该key的访问（读写）都会事先检测该key是否过期，如果过期就直接删除；但有一些键只访问一次，因此需要主动删除，默认情况下redis每秒检测10次，检测的对象是所有设置了过期时间的键集合，每次从这个集合中随机检测20个键查看他们是否过期，如果过期就直接删除，如果删除后还有超过25%的集合中的键已经过期，那么继续检测过期集合中的20个随机键进行删除。这样可以保证过期键最大只占所有设置了过期时间键的25%。

在Java中LRU的实现方式是使用HashMap结合双向链表，HashMap的值是双向链表的节点，双向链表的节点也保存一份key value。

LFU是在Redis4.0后出现的，LRU的最近最少使用实际上并不精确，考虑下孙歼面的情况，如果在|处删除，那么A距离的时间最久，但实际上A的使用频率要比B频繁，所以合理的淘汰策略应该是淘汰B。LFU就是为应对这种情况昌则而耐凯棚生的。

❿ 又没有c语言java语言比较厉害的帮我写个代码，不难，会的话估计不到20分钟就写完了页面lru算法

贴一个我写的LRU cache算法，用c++实现的
具体的数据结构用的一个链表加一张哈希表。
实现了set和get, 需要另外的功能我还可以再写。
class LRUCache{
struct cacheEntry{
int key;
int value;
cacheEntry(int c, int v):key(c),value(v){}
};

int _cap;
list<cacheEntry> entryList;
unordered_map<int, list<cacheEntry>::iterator> entryMap;

void moveToHead(list<cacheEntry>::iterator it, int key, int value)
{
entryList.erase(it);
cacheEntry tmp(key, value);
entryList.push_front(tmp);
entryMap[key]=entryList.begin();
}
public:
LRUCache(int capacity) {
_cap=capacity;
}

int get(int key) {
if(entryMap.find(key)==entryMap.end())
return -1;
else{
moveToHead(entryMap[key], key, entryMap[key]->value);
return entryMap[key]->value;
}
}

void set(int key, int value) {
if(entryMap.find(key)==entryMap.end()){
if(entryList.size()>=_cap){
entryMap.erase(entryList.back().key);
entryList.pop_back();
}
cacheEntry tmp(key, value);
entryList.push_front(tmp);
entryMap[key]=entryList.begin();
}
else{
entryMap[key]->value=value;
moveToHead(entryMap[key], key, value);
}
}
};