memcached的LRU删除机制

转载：http://www.cnblogs.com/liunianmoshi/p/memcached.html?utm_source=tuicool&utm_medium=referral

http://www.cnblogs.com/tujia/p/5413028.html

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝PART 1===============

1）memcached不会自动清空缓存的值
如果add了一个值，但不去get它，那么这个值过期了，它也不会被清空。
解释：memcached不自动检测和清空值，它只当你需要get这个值的时候，才检测这个值是否过期，过期则清空此值，并返回空。

PS：可使用stats命令查询 memcached的curr_items和total_items状态

2）memcached不会自动删除缓存的值
即使一个值过期了，memcached也不会删除它，只了清空了它的值，状态改为已过期。
真正删除值：只有当memcached内存满了，有新值需要占用空间，才会的把过期的值删除，存入新的值。

3）删除规则
刚刚说不自动删除值，只有当存入新的值，才会删除过期的值，那么删除哪一个过期值呢？？

FIFO删除机制
这是其他应用删除机制，队列的删除机制，first in first out，先进先出，删除最先来的那个值

memcached的LRU删除机制
memcached的删除机制是LRU删除机制，它并不是删除最新存的那个值，而是删除最少使用的那个值。

PS1：当get key的时候，此key的新鲜度更新为最新鲜，并不是新鲜度+1
PS2：这种LRU删除机制并不是只删除过期的值，如果memcached内存满了，即使最近的那个值还没过期，也会被踢除（永久数据被踢除现象）

=============PART 2==================

memcached是一个高性能的分布式内存缓存服务器，memcached在Linux上可以通过yum命令安装，这样方便很多，在生产环境下建议用Linux系统，memcached使用libevent这个库在Linux系统上才能发挥它的高性能。它的分布式其实在服务端是不具有分布式的特征的，是依靠客户端的分布式算法进行了分布式，memcached是一个纯内存型的数据库，这样在读写速度上相对来说比较快。

      memcached的内存分配是预先分配内存，常规的程序使用内存无非是两种，一种是预先分配，一种是动态分配。动态分配从效率的角度来讲相对来说要慢点，因为它需要实时的去分配内存使用，但是这种方式的好处就是可以节约内存使用空间；memcached采用的是预先分配的原则，这种方式是拿空间换时间的方式来提高它的速度，这种方式会造成不能很高效的利用内存空间，但是memcached采用了Slab Allocation机制来解决内存碎片的问题，Slab Allocation的基本原理就是按照预先规定的大小，将分配的内存分割成特定长度的块，并把尺寸相同的块分成组（chunk的集合），借用一下网上的图：

    

memcached会针对客户端发送的数据选择slab并缓存到chunk中，这样就有一个弊端那就是比如要缓存的数据大小是50个字节，如果被分配到如上图88字节的chunk中的时候就造成了33个字节的浪费，虽然在内存中不会存在碎片，但是也造成了内存的浪费，这也是我上面说的拿空间换时间的原因，不过memcached对于分配到的内存不会释放，而是重复利用。默认情况下如下图chunk是1.25倍的增加的，当然也可以自己通过-f设置，这种内部的分割算法可以参看源码下的slabs.c文件。

      

memcached本身内部不会监视记录是否过期，而是当get时依靠记录的过期时间检查是否过期，这也是memcached的一种惰性过期机制。默认情况下memcached内部也维护着一套LRU置换算法，当设定的内存满的时候，会进行最近很少使用的数据置换出去从而分配空间，所以对于提升memcached命中率的问题主要还是一是根据业务存放的value值来调整好chunk的大小以达到最大效率的利用内存；二是扩大内存保证所有缓存的数据不被置换出去。

      对于memcached的分布式完全就是依靠客户端的一致哈希算法来达到分布式的存储，因为本身各个memcached的服务器之间没办法通信，并不存在副本集或者主从的概念，它的分布式算法主要是先求出每一个memcached的服务器节点的哈希值，并将它们分配到2的32次方的圆上，然后根据存储的key的哈希值来映射到这个圆上，属于哪个区间顺时针找到的节点就存到这个服务器节点上，大致借用图表示如下图：

      

然而当添加新的memcached节点的时候必然会打乱现有这个圆的结构，这时候是没办法完全保证你以前的key依然会存在之前的节点上，但是这种结构却是能保证在添加缓存服务器的时候把损失降到最小，受结构调整后key不能命中的只有在这个圆上新增的服务器节点逆时针的第一台服务器上，其他的是不受影响的，借用图如下：

     

memcached和redis一样内部的存储都是key/Value的形式，正是这种哈希表数据结构保证了在内存中查找的时间的复杂度为O(1)，整体上memcached的高性能这两个哈希结构起了很大的作用，当然还有memcached的多路复用I/O模型也在高并发下起到了很大的作用。另外memcached的内部操作还具有CAS原子操作，这种利用CPU指令集的操作来保证在单个节点下数据的一致性，效率相对来说比加锁要高很多。

===========PART 3==============

LRU：是Least Recently Used 近期最少使用算法。 
Memcached的LRU几种策略 
1. 惰性删除。memcached一般不会主动去清除已经过期或者失效的缓存，当get请求一个item的时候，才会去检查item是否失效。 
2. flush命令。flush命令会将所有的item设置为失效。 
3. 创建的时候检查。Memcached会在创建ITEM的时候去LRU的链表尾部开始检查，是否有失效的ITEM，如果没有的话就重新创建。 
4. LRU爬虫。memcached默认是关闭LRU爬虫的。LRU爬虫是一个单独的线程，会去清理失效的ITEM。

==============PART 4==================

LRU缓存实现(Java)

• LRU Cache的LinkedHashMap实现
• LRU Cache的链表+HashMap实现
• LinkedHashMap的FIFO实现
• 调用示例

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，具体使用什么方式看个人喜好

//LinkedHashMap的一个构造函数，当参数accessOrder为true时，即会按照访问顺序排序，最近访问的放在最前，最早访问的放在后面

public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {

        super(initialCapacity, loadFactor);

        this.accessOrder = accessOrder;

}

//LinkedHashMap自带的判断是否删除最老的元素方法，默认返回false，即不删除老数据

//我们要做的就是重写这个方法，当满足一定条件时删除老数据

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {

        return false;

}

LRU缓存LinkedHashMap(inheritance)实现

采用inheritance方式实现比较简单，而且实现了Map接口，在多线程环境使用时可以使用 Collections.synchronizedMap()方法实现线程安全操作

package cn.lzrabbit.structure.lru;

import java.util.LinkedHashMap;

import java.util.Map;

/**

 * 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;

    }

    @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();

    }

}

 这样算是比较标准的实现吧，实际使用中这样写还是有些繁琐，更实用的方法时像下面这样写，省去了单独见一个类的麻烦

final int cacheSize = 100;

Map<String, String> map = new LinkedHashMap<String, String>((int) Math.ceil(cacheSize / 0.75f) + 1, 0.75f, true) {

    @Override

    protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {

    return size() > cacheSize;

    }

};

 

LRU缓存LinkedHashMap(delegation)实现

delegation方式实现更加优雅一些，但是由于没有实现Map接口，所以线程同步就需要自己搞定了

package cn.lzrabbit.structure.lru;

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

    }

}

 LRU Cache的链表+HashMap实现

 注：此实现为非线程安全，若在多线程环境下使用需要在相关方法上添加synchronized以实现线程安全操作

package cn.lzrabbit.structure.lru;

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;

    }

}

LinkedHashMap的FIFO实现

FIFO是First Input First Output的缩写，也就是常说的先入先出，默认情况下LinkedHashMap就是按照添加顺序保存，我们只需重写下removeEldestEntry方法即可轻松实现一个FIFO缓存，简化版的实现代码如下

final int cacheSize = 5;

LinkedHashMap<Integer, String> lru = new LinkedHashMap<Integer, String>() {

    @Override

    protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {

    return size() > cacheSize;

    }

};

调用示例

测试代码

package cn.lzrabbit.structure.lru;

import cn.lzrabbit.ITest;

import java.util.LinkedHashMap;

import java.util.Map;

/**

 * Created by liuzhao on 14-5-15.

 */

public class LRUCacheTest  {

    public static void main(String[] args) throws Exception {

        System.out.println("start...");

        lruCache1();

        lruCache2();

        lruCache3();

        lruCache4();

     

        System.out.println("over...");

    }

 

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

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

    }

static   <T> void lruCache2() {

        System.out.println();

        System.out.println("===========================LRU LinkedHashMap(inheritance)实现===========================");

        LRUCache2<Integer, String> lru = new LRUCache2(5);

        lru.put(1, "11");

        lru.put(2, "11");

        lru.put(3, "11");

        lru.put(4, "11");

        lru.put(5, "11");

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

    }

  static  void lruCache3() {

        System.out.println();

        System.out.println("===========================LRU LinkedHashMap(delegation)实现===========================");

        LRUCache3<Integer, String> lru = new LRUCache3(5);

        lru.put(1, "11");

        lru.put(2, "11");

        lru.put(3, "11");

        lru.put(4, "11");

        lru.put(5, "11");

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

    }

  static  void lruCache4() {

        System.out.println();

        System.out.println("===========================FIFO LinkedHashMap默认实现===========================");

        final int cacheSize = 5;

        LinkedHashMap<Integer, String> lru = new LinkedHashMap<Integer, String>() {

            @Override

            protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {

                return size() > cacheSize;

            }

        };

        lru.put(1, "11");

        lru.put(2, "11");

        lru.put(3, "11");

        lru.put(4, "11");

        lru.put(5, "11");

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

    }

}

运行结果

"C:\Program Files (x86)\Java\jdk1.6.0_10\bin\java" -Didea.launcher.port=7535 "-Didea.launcher.bin.path=C:\Program Files (x86)\JetBrains\IntelliJ IDEA 13.0.2\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\charsets.jar;C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\deploy.jar;C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\javaws.jar;C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\jce.jar;C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\jsse.jar;C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\management-agent.jar;C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\plugin.jar;C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\resources.jar;C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\rt.jar;C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\ext\dnsns.jar;C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\ext\localedata.jar;C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\ext\sunjce_provider.jar;C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\ext\sunmscapi.jar;C:\Program Files (x86)\Java\jdk1.6.0_10\jre\lib\ext\sunpkcs11.jar;D:\SVN\projects\Java\Java.Algorithm\target\test-classes;D:\SVN\projects\Java\Java.Algorithm\target\classes;C:\Program Files (x86)\JetBrains\IntelliJ IDEA 13.0.2\lib\idea_rt.jar" com.intellij.rt.execution.application.AppMain Main

start...

===========================LRU 链表实现===========================

5:11 4:11 3:11 2:11 1:11 

4:11 7:77 2:11 6:66 5:11 

===========================LRU LinkedHashMap(inheritance)实现===========================

1:11 2:11 3:11 4:11 5:11 

5:11 6:66 2:11 7:77 4:11 

===========================LRU LinkedHashMap(delegation)实现===========================

1:11 2:11 3:11 4:11 5:11 

5:11 6:66 2:11 7:77 4:11 

===========================FIFO LinkedHashMap默认实现===========================

{1=11, 2=11, 3=11, 4=11, 5=11}

{3=11, 4=11, 5=11, 6=66, 7=77}

over...

Process finished with exit code 0