LRU緩存實現(Java)

LRU是Least Recently Used 的縮寫，翻譯過來就是“最近最少使用”，LRU緩存就是使用這種原理實現，簡單的說就是緩存一定量的數據，當超過設定的閾值時就把一些過期的數據刪除掉，比如我們緩存10000條數據，當數據小於10000時可以隨意添加，當超過10000時就需要把新的數據添加進來，同時要把過期數據刪除，以確保我們最大緩存10000條，那怎麼確定刪除哪條過期數據呢，採用LRU算法實現的話就是將最老的數據刪掉，廢話不多說，下面來說下Java版的LRU緩存實現。

Java裏面實現LRU緩存通常有兩種選擇，一種是使用LinkedHashMap，一種是自己設計數據結構，使用鏈表+HashMap

LRU Cache的LinkedHashMap

LinkedHashMap自身已經實現了順序存儲，默認情況下是按照元素的添加順序存儲，也可以啓用按照訪問順序存儲，即最近讀取的數據放在最前面，最早讀取的數據放在最後面，然後它還有一個判斷是否刪除最老數據的方法，默認是返回false，即不刪除數據，我們使用LinkedHashMap實現LRU緩存的方法就是對LinkedHashMap實現簡單的擴展，擴展方式有兩種，一種是inheritance，一種是delegation，具體使用什麼方式看個人喜好。

LRU緩存LinkedHashMap(inheritance)實現

採用inheritance方式實現比較簡單，而且實現了Map接口，在多線程環境使用時可以使用 Collections.synchronizedMap()方法實現線程安全操作

import java.util.LinkedHashMap;
import java.util.Map;


public class LRUCache2<K, V> extends LinkedHashMap<K, V> {
    private final int MAX_CACHE_SIZE;

    public LRUCache2(int cacheSize) {
        super((int) Math.ceil(cacheSize / 0.75) + 1, 0.75f, true);
        MAX_CACHE_SIZE = cacheSize;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry eldest) {
        return size() > MAX_CACHE_SIZE;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<K, V> entry : entrySet()) {
            sb.append(String.format("%s:%s ", entry.getKey(), entry.getValue()));
        }
        return sb.toString();
    }
}

LRU緩存LinkedHashMap(delegation)實現

delegation方式實現更加優雅一些，但是由於沒有實現Map接口，所以線程同步就需要自己搞定了

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

/**
 * Created by liuzhao on 14-5-13.
 */
public class LRUCache3<K, V> {

    private final int MAX_CACHE_SIZE;
    private final float DEFAULT_LOAD_FACTOR = 0.75f;
    LinkedHashMap<K, V> map;

    public LRUCache3(int cacheSize) {
        MAX_CACHE_SIZE = cacheSize;
        //根據cacheSize和加載因子計算hashmap的capactiy，+1確保當達到cacheSize上限時不會觸發hashmap的擴容，
        int capacity = (int) Math.ceil(MAX_CACHE_SIZE / DEFAULT_LOAD_FACTOR) + 1;
        map = new LinkedHashMap(capacity, DEFAULT_LOAD_FACTOR, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry eldest) {
                return size() > MAX_CACHE_SIZE;
            }
        };
    }

    public synchronized void put(K key, V value) {
        map.put(key, value);
    }

    public synchronized V get(K key) {
        return map.get(key);
    }

    public synchronized void remove(K key) {
        map.remove(key);
    }

    public synchronized Set<Map.Entry<K, V>> getAll() {
        return map.entrySet();
    }

    public synchronized int size() {
        return map.size();
    }

    public synchronized void clear() {
        map.clear();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry entry : map.entrySet()) {
            sb.append(String.format("%s:%s ", entry.getKey(), entry.getValue()));
        }
        return sb.toString();
    }
}

如果你去看LinkedHashMap的源碼可知，LRU算法是通過雙向鏈表來實現，當某個位置被命中，通過調整鏈表的指向將該位置調整到頭位置，新加入的內容直接放在鏈表頭，如此一來，最近被命中的內容就向鏈表頭移動，需要替換時，鏈表最後的位置就是最近最少使用的位置。

 LRU Cache的鏈表+HashMap實現

　　傳統意義的LRU算法是爲每一個Cache對象設置一個計數器，每次Cache命中則給計數器+1，而Cache用完，需要淘汰舊內容，放置新內容時，就查看所有的計數器，並將最少使用的內容替換掉。

   它的弊端很明顯，如果Cache的數量少，問題不會很大， 但是如果Cache的空間過大，達到10W或者100W以上，一旦需要淘汰，則需要遍歷所有計算器，其性能與資源消耗是巨大的。效率也就非常的慢了。

    它的原理： 將Cache的所有位置都用雙連表連接起來，當一個位置被命中之後，就將通過調整鏈表的指向，將該位置調整到鏈表頭的位置，新加入的Cache直接加到鏈表頭中。

     這樣，在多次進行Cache操作後，最近被命中的，就會被向鏈表頭方向移動，而沒有命中的，而想鏈表後面移動，鏈表尾則表示最近最少使用的Cache。

     當需要替換內容時候，鏈表的最後位置就是最少被命中的位置，我們只需要淘汰鏈表最後的部分即可。

  上面說了這麼多的理論， 下面用代碼來實現一個LRU策略的緩存。

    我們用一個對象來表示Cache，並實現雙鏈表

下面給出完整的實現

import java.util.HashMap;


public class LRUCache1<K, V> {

    private final int MAX_CACHE_SIZE;
    private Entry first;
    private Entry last;

    private HashMap<K, Entry<K, V>> hashMap;

    public LRUCache1(int cacheSize) {
        MAX_CACHE_SIZE = cacheSize;
        hashMap = new HashMap<K, Entry<K, V>>();
    }

    public void put(K key, V value) {
        Entry entry = getEntry(key);
        if (entry == null) {
            if (hashMap.size() >= MAX_CACHE_SIZE) {
                hashMap.remove(last.key);
                removeLast();
            }
            entry = new Entry();
            entry.key = key;
        }
        entry.value = value;
        moveToFirst(entry);
        hashMap.put(key, entry);
    }

    public V get(K key) {
        Entry<K, V> entry = getEntry(key);
        if (entry == null) return null;
        moveToFirst(entry);
        return entry.value;
    }

    public void remove(K key) {
        Entry entry = getEntry(key);
        if (entry != null) {
            if (entry.pre != null) entry.pre.next = entry.next;
            if (entry.next != null) entry.next.pre = entry.pre;
            if (entry == first) first = entry.next;
            if (entry == last) last = entry.pre;
        }
        hashMap.remove(key);
    }

    private void moveToFirst(Entry entry) {
        if (entry == first) return;
        if (entry.pre != null) entry.pre.next = entry.next;
        if (entry.next != null) entry.next.pre = entry.pre;
        if (entry == last) last = last.pre;

        if (first == null || last == null) {
            first = last = entry;
            return;
        }

        entry.next = first;
        first.pre = entry;
        first = entry;
        entry.pre = null;
    }

    private void removeLast() {
        if (last != null) {
            last = last.pre;
            if (last == null) first = null;
            else last.next = null;
        }
    }


    private Entry<K, V> getEntry(K key) {
        return hashMap.get(key);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        Entry entry = first;
        while (entry != null) {
            sb.append(String.format("%s:%s ", entry.key, entry.value));
            entry = entry.next;
        }
        return sb.toString();
    }

    class Entry<K, V> {
        public Entry pre;
        public Entry next;
        public K key;
        public V value;
    }
}

LinkedHashMap的FIFO實現

FIFO是First Input First Output的縮寫，也就是常說的先入先出，默認情況下LinkedHashMap就是按照添加順序保存，我們只需重寫下removeEldestEntry方法即可輕鬆實現一個FIFO緩存。