实现 Java 本地缓存，该从这几点开始

缓存，我相信你们对它必定不陌生，在项目中，缓存确定是必不可少的。市面上有很是多的缓存工具，好比 Redis、Guava Cache 或者 EHcache。对于这些工具，我想你们确定都很是熟悉，因此今天咱们不聊它们，咱们来聊一聊如何实现本地缓存。参考上面几种工具，要实现一个较好的本地缓存，平头哥认为要从如下三个方面开始。

一、存储集合的选择

实现本地缓存，存储容器确定是 key/value 形式的数据结构，在 Java 中，也就是咱们经常使用的 Map 集合。Map 中有 HashMap、Hashtable、ConcurrentHashMap 几种供咱们选择，若是不考虑高并发状况下数据安全问题，咱们能够选择HashMap，若是考虑高并发状况下数据安全问题，咱们能够选择 Hashtable、ConcurrentHashMap 中的一种集合，可是咱们优先选择 ConcurrentHashMap，由于 ConcurrentHashMap 的性能比 Hashtable 要好。

二、过时缓存处理

由于缓存直接存储在内存中，若是咱们不处理过时缓存，内存将被大量无效缓存占用，这不是咱们想要的，因此咱们须要清理这些失效的缓存。过时缓存处理能够参考 Redis 的策略来实现，Redis 采用的是按期删除 + 懒惰淘汰策略。

按期删除策略

按期删除策略是每隔一段时间检测已过时的缓存，而且降之删除。这个策略的优势是可以确保过时的缓存都会被删除。同时也存在着缺点，过时的缓存不必定可以及时的被删除，这跟咱们设置的定时频率有关系，另外一个缺点是若是缓存数据较多时，每次检测也会给 cup 带来不小的压力。

懒惰淘汰策略

懒惰淘汰策略是在使用缓存时，先判断缓存是否过时，若是过时将它删除，而且返回空。这个策略的优势是只有在查找的时候，才判断是否过时，对 CUP 影响较。同时这种策略有致命的缺点，当存入了大量的缓存，这些缓存都没有被使用而且已过时，都将成为无效缓存，这些无效的缓存将占用你大量的内存空间，最后致使服务器内存溢出。

咱们简单的了解了一下 Redis 的两种过时缓存处理策略，每种策略都存在本身的优缺点。因此咱们在使用过程当中，能够将两种策略组合起来，结合效果仍是很是理想的。

三、缓存淘汰策略

缓存淘汰跟过时缓存处理要区别开来，缓存淘汰是指当咱们的缓存个数达到咱们指定的缓存个数时，毕竟咱们的内存不是无限的。若是咱们须要继续添加缓存的话，咱们就须要在现有的缓存中根据某种策略淘汰一些缓存，给新添加的缓存腾出位置，下面一块儿来认识几种经常使用的缓存淘汰策略。

先进先出策略

最早进入缓存的数据在缓存空间不够的状况下会被优先被清除掉，以腾出新的空间接受新的数据。该策略主要比较缓存元素的建立时间。在一些对数据实效性要求比较高的场景下，可考虑选择该类策略，优先保障最新数据可用。

最少使用策略

不管是否过时，根据元素的被使用次数判断，清除使用次数较少的元素释放空间。该策略主要比较元素的hitCount（命中次数），在保证高频数据有效性场景下，可选择这类策略。

最近最少使用策略

不管是否过时，根据元素最后一次被使用的时间戳，清除最远使用时间戳的元素释放空间。该策略主要比较缓存最近一次被get使用时间。在热点数据场景下较适用，优先保证热点数据的有效性。

随机淘汰策略

不管是否过时，随机淘汰某个缓存，若是对缓存数据没有任何要求，能够考虑使用该策略。

不淘汰策略

当缓存达到指定值以后，不淘汰任何缓存，而是不能新增缓存，直到有缓存淘汰时，才能继续添加缓存。

上面是实现本地缓存须要考虑的三个点，看完咱们应该知该如何实现一个本地缓存了，不妨咱们一块儿来实现一个本地缓存。

实现本地缓存

在该 Demo 中，咱们采用 ConcurrentHashMap 做为存储集合，这样即便在高并发的状况下，咱们也可以保证缓存的安全。过时缓存处理在这里我只使用了定时删除策略，并无使用定时删除 + 懒惰淘汰策略，你能够本身动手尝试一下使用这两种策略进行过时缓存处理。在缓存淘汰方面，我在这里采用了最少使用策略。好了，技术选型都知道了，咱们一块儿来看看代码实现。

缓存对象类

public class Cache implements Comparable<Cache>{
    // 键
    private Object key;
    // 缓存值
    private Object value;
    // 最后一次访问时间
    private long accessTime;
    // 建立时间
    private long writeTime;
    // 存活时间
    private long expireTime;
    // 命中次数
    private Integer hitCount;
    ...getter/setter()...
复制代码

添加缓存

/** * 添加缓存 * * @param key * @param value */
public void put(K key, V value,long expire) {
    checkNotNull(key);
    checkNotNull(value);
    // 当缓存存在时，更新缓存
    if (concurrentHashMap.containsKey(key)){
        Cache cache = concurrentHashMap.get(key);
        cache.setHitCount(cache.getHitCount()+1);
        cache.setWriteTime(System.currentTimeMillis());
        cache.setAccessTime(System.currentTimeMillis());
        cache.setExpireTime(expire);
        cache.setValue(value);
        return;
    }
    // 已经达到最大缓存
    if (isFull()) {
        Object kickedKey = getKickedKey();
        if (kickedKey !=null){
            // 移除最少使用的缓存
            concurrentHashMap.remove(kickedKey);
        }else {
            return;
        }
    }
    Cache cache = new Cache();
    cache.setKey(key);
    cache.setValue(value);
    cache.setWriteTime(System.currentTimeMillis());
    cache.setAccessTime(System.currentTimeMillis());
    cache.setHitCount(1);
    cache.setExpireTime(expire);
    concurrentHashMap.put(key, cache);
}
复制代码

获取缓存

/** * 获取缓存 * * @param key * @return */
public Object get(K key) {
    checkNotNull(key);
    if (concurrentHashMap.isEmpty()) return null;
    if (!concurrentHashMap.containsKey(key)) return null;
    Cache cache = concurrentHashMap.get(key);
    if (cache == null) return null;
    cache.setHitCount(cache.getHitCount()+1);
    cache.setAccessTime(System.currentTimeMillis());
    return cache.getValue();
}
复制代码

获取最少使用的缓存

/** * 获取最少使用的缓存 * @return */
    private Object getKickedKey() {
        Cache min = Collections.min(concurrentHashMap.values());
        return min.getKey();
    }
复制代码

过时缓存检测方法

/** * 处理过时缓存 */
class TimeoutTimerThread implements Runnable {
    public void run() {
        while (true) {
            try {
                TimeUnit.SECONDS.sleep(60);
                expireCache();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /** * 建立多久后，缓存失效 * * @throws Exception */
    private void expireCache() throws Exception {
        System.out.println("检测缓存是否过时缓存");
        for (Object key : concurrentHashMap.keySet()) {
            Cache cache = concurrentHashMap.get(key);
            long timoutTime = TimeUnit.NANOSECONDS.toSeconds(System.nanoTime()
                    - cache.getWriteTime());
            if (cache.getExpireTime() > timoutTime) {
                continue;
            }
            System.out.println(" 清除过时缓存 ： " + key);
            //清除过时缓存
            concurrentHashMap.remove(key);
        }
    }
}
复制代码

上面是主要代码，完整的代码我已经上传至 GitHub

本文从实现本地缓存的设计角度，一块儿简单的探讨了一下实现本地缓存须要注意的地方，其实这些也是缓存的核心技术，不论是 Redis、Guava Cache 仍是 EHcache或者其余缓存工具，它们在实现原理上，跟咱们本地缓存的实现原理都差很少。只要咱们理解了本地缓存的实现原理，在去学习这些缓存工具，我相信仍是会比较轻松的。

文章不足之处，望你们多多指点，共同窗习，共同进步

最后

打个小广告，欢迎扫码关注微信公众号：「平头哥的技术博文」，一块儿进步吧。