轉：LRU算法

LRU是Least Recently Used的縮寫，即最近最少使用頁面置換算法，是爲虛擬頁式存儲管理服務的，是根據頁面調入內存後的使用狀況進行決策了。因爲沒法預測各頁面未來的使用狀況，只能利用「最近的過去」做爲「最近的未來」的近似，所以，LRU算法就是將最近最久未使用的頁面予以淘汰。

能夠用一個特殊的棧來保存當前正在使用的各個頁面的頁面號。當一個新的進程訪問某頁面時，便將該頁面號壓入棧頂，其餘的頁面號往棧底移，若是內存不夠，則將棧底的頁面號移除。這樣，棧頂始終是最新被訪問的頁面的編號，而棧底則是最近最久未訪問的頁面的頁面號。

        如輸入如下序列時：4,7,0,7,1,0,1,2,1,2,6

        結果爲：

4        
4        7        
4        7        0        
4        0        7        
4        0        7        1        
4        7        1        0        
4        7        0        1        
4        7        0        1        2        
4        7        0        2        1        
4        7        0        1        2        
7        0        1        2        6        

 

 

   用Java代碼實現LRU算法以下：

import java.util.ArrayList;  
import java.util.List;  
  
  
public class LRU {  
    /** 
     * 內存塊的個數 
     */  
    public static final int N = 5;  
    /** 
     * 內存塊數組 
     */  
    Object[] array = new Object[N];  
    private int size;  
      
    public LRU() {  
    }  
    /** 
     * 判斷內存區是否爲空 
     * @return 
     */  
    public boolean isEmpty() {  
        if(size == 0) {  
            return true;  
        } else {  
            return false;  
        }  
    }  
    /** 
     * 判斷內存區是否達到最大值 
     * @return 
     */  
    public boolean isOutOfBoundary() {  
        if(size >=N) {  
            return true;  
        } else {  
            return false;  
        }  
    }  
    /** 
     * 查找元素o在數組中的位置 
     * @param o 
     * @return 
     */  
    public int indexOfElement(Object o) {  
        for(int i=0; i<N; i++) {   
            if(o == array[i]) {  
                return i;  
            }  
        }  
        return -1;  
    }     
    /** 
     * 有新的數據o須要申請內存 
     * @param o 
     * @return 移出內存區的數據 
     */  
    public Object push(Object o) {  
        int t = -1;  
        if(!isOutOfBoundary() && indexOfElement(o) == -1){  
            array[size] = o;  
            size ++;  
        } else if(isOutOfBoundary() && indexOfElement(o) == -1){  
            for(int i=0; i<size-1; i++) {  
                array[i] = array[i+1];                
            }  
            array[size-1] = o;  
        } else {  
            t = indexOfElement(o);  
            for(int i=t; i<size-1; i++) {  
                array[i] = array[i+1];  
            }  
            array[size-1] = o;  
        }  
        if( -1 == t) {  
            return null;  
        } else {  
            return array[t];  
        }  
    }  
    /** 
     * 輸出內存區中的各數據 
     */  
    public void showMemoryBlock() {  
        for(int i=0; i<size; i++) {  
            System.out.print(array[i] + "\t");  
        }  
    }  
  
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        Integer iter[] = {4,7,0,7,1,0,1,2,1,2,6};  
        LRU lru = new LRU();  
        for(int i=0; i<iter.length; i++) {  
            lru.push(iter[i]);  
            lru.showMemoryBlock();  
            System.out.println();  
        }  
    }  
  
}  

        LRU算法也能夠用於一些實際的應用中，如你要作一個瀏覽器，或相似於淘寶客戶端的應用的就要用到這個原理。你們都知道瀏覽器在瀏覽網頁的時候會把下載的圖片臨時保存在本機的一個文件夾裏，下次再訪問時就會，直接從本機臨時文件夾裏讀取。但保存圖片的臨時文件夾是有必定容量限制的，若是你瀏覽的網頁太多，就會一些你最不常使用的圖像刪除掉，只保留最近最久使用的一些圖片。這時就能夠用到LRU算法 了，這時上面算法裏的這個特殊的棧就不是保存頁面的序號了，而是每一個圖片的序號或大小；因此上面這個棧的元素都用Object類來表示，這樣的話這個棧就能夠保存的對像了。