LRU的cache的实现

在网上看到一道面试题：LRU的cache设计，正好最近在学习memcached，于是很认真的研究了下这个问题

最笨的实现
一个数组，所有数据堆里边，每个数据维护一个时间（上一次被使用的时间），当查找某个数据的时候，遍历数组。当cache满的时候，需要遍历找到最久没变使用的记录，然后删除。这两个遍历充分暴露了这种实现的笨。

在网上搜了一下，看到大致有两种实现
1.直接利用linkedhashmap
2.使用hashmap+链表。

这两种思路是同一种思想，就是结合hashmap和链表进行存储
- hashmap可以实现快速查找
- 链表从表头到表尾是按从最近到最久访问的顺序维护的，这样当
需要失效最久未使用的时候直接把tail失效掉即可

linkedhashmap

private transient Entry header;

刚看到这边的时候想怎么只有header呢，按理说不应该维护header和tail么，后来经过研究，发现是一个环形的双向链表。so，header的before是链表头，header的fater是链表尾

put(D)后的数据结构

get(B)后，B在原位置删除，加到header的before的位置

 private static class Entry extends HashMap.Entry
    {

        private void remove()
        {
            before.after = after;
            after.before = before;
        }

        private void addBefore(Entry entry)
        {
            after = entry;
            before = entry.before;
            before.after = this;
            after.before = this;
        }
        //最关键的一个方法，实现按访问先后排序
        void recordAccess(HashMap hashmap)
        {
            LinkedHashMap linkedhashmap = (LinkedHashMap)hashmap;
            //accessOrder是否根据放入顺序排序的开关
            if(linkedhashmap.accessOrder)
            {
                linkedhashmap.modCount++;
                //先删除
                remove();
                //再加入header的before位置
                addBefore(linkedhashmap.header);
            }
        }

        Entry before;
        Entry after;       
    }

linkedhashmap 已经把最核心的基础准备好了

   void addEntry(int i, Object obj, Object obj1, int j)
    {
        createEntry(i, obj, obj1, j);
        Entry entry = header.after;
        if(removeEldestEntry(entry))
            removeEntryForKey(entry.key);
        else
        if(size >= threshold)
            resize(2 * table.length);
    }

    protected boolean removeEldestEntry(Map.Entry entry)
    {
        return false;
    }

removeEldestEntry方法默认是返回false，即不会删除链表尾的数据，这个地方需要重载一下这个方法

/**
 * Created by liuzhao on 14-5-15.
 */
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;
    }
}

hashmap+链表

package cache;


import java.util.HashMap;

/**
 * Created by liuzhao on 14-5-12.
 */
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;
    }

    static   void lruCache1() {
        System.out.println();
        System.out.println("===========================LRU 链表实现===========================");
        LRUCache1<Integer, String> lru = new LRUCache1(5);
        lru.put(1, "11");
        lru.put(2, "11");
        lru.put(3, "11");
        lru.put(4, "11");
        lru.put(5, "11");
        lru.put(5, "12");
        System.out.println(lru.toString());
        lru.put(6, "66");
        lru.get(2);
        lru.put(7, "77");
        lru.get(4);
        System.out.println(lru.toString());
        System.out.println();
    }

    public static void main(String[] args) {
        lruCache1();
    }

}

memcached的实现

使用内存保存数据总会有满的情况，满就得淘汰，而memcached中的淘汰机制是LRU（最近最少使用算法 ），所以每个slabclass都保存着一个LRU队列，而head[i]和tail[i]则就是id为i的slabclass LRU队列的头部和尾部，尾部的item是最应该淘汰的项，也就是最近最少使用的项。