用Java实现多种缓存机制

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u012403290/article/details/68926201

引言

在学习的过程中，遇到用java写一个LRU缓存。鉴于此，把所有缓存机制的缓存都整理了一下，并自己写了几套，主要分为FIFO，LRU和LFU三种，在技术点中会解释这三种是什么意思。大家一起研究和优化。笔者目前整理的一些blog针对面试都是超高频出现的。大家可以点击链接：http://blog.csdn.net/u012403290

技术点：

1、FIFO（First In First Out）：
先入先出，很好理解，就和队列一样，先进队列的先出队列。

2、LRU（Least Recently Used）：
最近最少使用，意思就是最近读取的数据放在最前面，最早读取的数据放在最后面，如果这个时候有新的数据进来，那么最后面存储的数据淘汰。

3、LFU（Least Frequently Used）：
最不常使用，意思就是对存储的数据都会有一个计数引用，然后队列按数据引用次数排序，引用数多的排在最前面，引用数少的排在后面。如果这个时候有新的数据进来，把最后面的数据删除，把新进数据排在最后面，且引用次数为1

说道缓存机制，大家肯定都会想到redis，缓存必须要用key-value这样的键值对，因为在获取缓存数据的时候，必然会用key查询value的值。所以用Map实现缓存，是非常好的机制，同时我们可以在java本身就有的类进行扩展。

简单介绍一下LinkedHashMap，它是一个非线程安全的集合，它默认是按存储的顺序进行排序，而且还有一个自带的移除方法：

    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }

从源码可以看出，它本身就是返回false的，所以只要在子类中重写这个方法就可以按照我们自己的定义去实现它。同时LinkedHashMap还有一个天然的LRU机制，它支持访问过的数据放在最前面，以下是它的一个源码构造函数：

    /**
     * Constructs an empty <tt>LinkedHashMap</tt> instance with the
     * specified initial capacity, load factor and ordering mode.
     *
     * @param  initialCapacity the initial capacity
     * @param  loadFactor      the load factor
     * @param  accessOrder     the ordering mode - <tt>true</tt> for
     *         access-order, <tt>false</tt> for insertion-order
     * @throws IllegalArgumentException if the initial capacity is negative
     *         or the load factor is nonpositive
     */
    public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }

默认情况下，accessOrder是false的，如果设置成true就可以达到访问过的数据就排到最前面。

注意：三种缓存机制的实现方法有很多，我只是写出了各个方式的其中一种，大家可以集思广益。同时，我这几种实现当中都没有实现线程安全。

FIFO实现：
LinkedHashMap默认就是按存储的数据排序的，满足先进先出规则，所以可以继承LinkedHashMap实现基于FIFO的缓存机制：

package com.brickworkers;

import java.util.LinkedHashMap;

public class FIFOCache<K,V> extends LinkedHashMap<K, V>{

    private static final long serialVersionUID = 436014030358073695L;

    private final int SIZE;

    public FIFOCache(int size) {
        super();//调用父类无参构造，不启用LRU规则
        SIZE = size;
    }

    //重写淘汰机制
    @Override
    protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
        return size() > SIZE;  //如果缓存存储达到最大值删除最后一个
    }


}

FIFO测试类：

package com.brickworkers;

public class CacheTest {

    public static void main(String[] args) {
        FIFOCache<Integer, Integer> map = new FIFOCache<Integer, Integer>(10);//设置容量为10
        for (int i = 0; i++ < 10;) {
            map.put(i, i);   //放入1-10总10个数据
        }
        System.out.println("起始存储情况："+map.toString());//打印起始存储情况

        map.put(8, 8);  //存入一个已存在的数据，也就是命中一次缓存中的数据
        System.out.println("命中一个已存在的数据："+map.toString());//打印命中之后的情况

        map.put(11, 11); //又存入缓存之外的数据
        System.out.println("新增一个数据后："+map.toString());//打印又存储一个数据之后的情况
    }

}

//输出结果：
//起始存储情况：{1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9, 10=10}
//命中一个已存在的数据：{1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9, 10=10}
//新增一个数据后：{2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9, 10=10, 11=11}

从上面的测试结果来看，的确是FIFO规则的吧。首先是按存入的顺序进行排序的，如果命中缓存中的任意一个数据，也不会破坏先进先出的规则。如果新增了一个缓存之外的数据，会把最先存入的数据移除。

LRU
启用LinkedHashMap的LRU机制，以下是源码：

package com.brickworkers;

import java.util.LinkedHashMap;

public class LRUCache<K,V> extends LinkedHashMap<K, V> {
    private static final long serialVersionUID = 5853563362972200456L;

    private final int SIZE;

    public LRUCache(int size) {
        super(size, 0.75f, true);  //int initialCapacity, float loadFactor, boolean accessOrder这3个分别表示容量，加载因子和是否启用LRU规则
        SIZE = size;
    }

    @Override
    protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
        return size() > SIZE;
    }
}

其实这里还是有优化的，试想一下合理构造LinkedHashMap，控制临界点的扩容操作。构造函数第三个参数就是启用了最近访问的数据放到最前面的规则。

LRU测试类：

package com.brickworkers;

public class CacheTest {

    public static void main(String[] args) {
//      FIFOCache<Integer, Integer> map = new FIFOCache<Integer, Integer>(10);//设置容量为10

        LRUCache<Integer, Integer> map = new LRUCache<Integer, Integer>(10);

        for (int i = 0; i++ < 10; ) {
            map.put(i, i);   //放入1-10总10个数据
        }
        System.out.println("起始存储情况："+map.toString());//打印起始存储情况

        map.get(7);
        System.out.println("命中一个已存在的数据："+map.toString());//打印命中之后的情况

        map.put(8, 8+1);  //存入一个已存在的数据，也就是命中一次缓存中的数据
        System.out.println("覆盖一个已存在的数据："+map.toString());//打印命中之后的情况

        map.put(11, 11); //又存入缓存之外的数据
        System.out.println("新增一个数据后："+map.toString());//打印又存储一个数据之后的情况
    }

}

//输出结果
//起始存储情况：{1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9, 10=10}
//命中一个已存在的数据：{1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 8=8, 9=9, 10=10, 7=7}
//覆盖一个已存在的数据：{1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 9=9, 10=10, 7=7, 8=9}
//新增一个数据后：{2=2, 3=3, 4=4, 5=5, 6=6, 9=9, 10=10, 7=7, 8=9, 11=11}

从测试类的结果可以看出，当某一个数据被访问命中就会按照LRU规则放到队列最前面。如果新增一个不存在缓存的数据，会把该数据放到最前面，同时移除最早访问过的数据。

LFU
LFU算法其实还要考虑命中时间，我这里不做考虑的，只考虑命中次数，大家可以自己尝试加一个时间和命中次数的综合排序:

package com.brickworkers;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 
 * @author Brickworker
 * Date:2017年3月31日下午3:38:19 
 * 关于类LFUCache.java的描述：
 * Copyright (c) 2017, brcikworker All Rights Reserved.
 */
public class LFUCache{


    static class Value implements Comparable<Value>{    //定义一个静态内部类，主要是用于统计命中数
        Object key;
        Object val;
        int hitCount;

        public Value(Object v, Object key) {
            this.key = key;
            this.val = v;
            this.hitCount = 1;  //第一次进入设置命中为1
        }

        public void setVal(Object obj){
            this.val = obj;
        }

        public void countInc(){
            hitCount++;
        }

        @Override
        public int compareTo(Value o) {
            if(o instanceof Value){  //如果比较的类属于Value或者是Value的子类
                Value v = (Value) o;
                if(this.hitCount > v.hitCount)
                    return 1;
                else
                    return -1;
            }
            return 0;
        }


    }
    final int SIZE;

    private Map<Object, Value> map = new HashMap<Object, Value>();

    public LFUCache(int size) {
        SIZE = size;
    }


    //获取缓存中的数据
    public Object get(Object k){
        if(k == null)
            return null;

        //命中+1
        map.get(k).countInc();
        return map.get(k).val;
    }

    //存储数据
    public void put(Object k, Object v){
        //如果本来就存在
        if(map.get(k) != null){
            map.get(k).countInc();//命中计数
            map.get(k).setVal(v);//覆盖结果值
        }else{
            //如果存储已超过限定值
            if(map.size() >= SIZE){
                remove();//移除最后一个数据
            }
            Value value  = new Value(v, k);
            map.put(k, value);
        }


        //
    }


    //数据移除最后一个数据
    public void remove(){
        //先拿到最后一个数据
        Value v = Collections.min(map.values());
        //移除最后一个数据
        map.remove(v.key);
    }


    //获取存储情况
    public String showList(){
        List<Value> list = new ArrayList<Value>();
        list.addAll(map.values());
        Collections.sort(list);
        String result = "";
        for (Value value : list) {
            result +=value.key+"="+value.val+"  ";
        }
        return result;
    }


}

测试类：

package com.brickworkers;

public class CacheTest {

    public static void main(String[] args) {
//      FIFOCache<Integer, Integer> map = new FIFOCache<Integer, Integer>(10);//设置容量为10

//      LRUCache<Integer, Integer> map = new LRUCache<Integer, Integer>(10);

        LFUCache map = new LFUCache(10);

        for (int i = 0; i++ < 10; ) {
            map.put(i, i);   //放入1-10总10个数据
        }
        System.out.println("起始存储情况："+map.showList());//打印起始存储情况

        map.get(7);
        System.out.println("命中一个已存在的数据："+map.showList());//打印命中之后的情况

        map.put(8, 8+1);  //存入一个已存在的数据，也就是命中一次缓存中的数据
        System.out.println("覆盖一个已存在的数据："+map.showList());//打印命中之后的情况

        map.put(11, 11); //又存入缓存之外的数据
        System.out.println("新增一个数据后："+map.showList());//打印又存储一个数据之后的情况

        map.put(5, 5); //连续命中两次5
        map.put(5, 5);
        map.put(6, 6); //连续命中三次6
        map.put(6, 6);
        map.put(6, 6);
        System.out.println("修改命中次数后："+map.showList());//打印又存储一个数据之后的情况

    }

}

//输出结果
//起始存储情况：10=10  9=9  8=8  7=7  6=6  5=5  4=4  3=3  2=2  1=1  
//命中一个已存在的数据：10=10  9=9  8=8  6=6  5=5  4=4  3=3  2=2  1=1  7=7  
//覆盖一个已存在的数据：10=10  9=9  6=6  5=5  4=4  3=3  2=2  1=1  8=9  7=7  
//新增一个数据后：11=11  9=9  6=6  5=5  4=4  3=3  2=2  1=1  8=9  7=7  
//修改命中次数后：11=11  9=9  4=4  3=3  2=2  1=1  8=9  7=7  5=5  6=6  

从测试结果可以一目了然看到，当命中次数越多，它的排名就会越靠前。但是个人觉得LFU实现的有点丑，大家可以改进，甚至是换个思路，比如说TreeMap可以实现排序，但是我没有去尝试。好啦，大家有什么意见和建议记得联系我呗。