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);
}
}
};