ConcurrentHashMap实现Localcache本地缓存

很多场景下，有些请求的数据，是不会经常改变的，这种时候，为了减少数据库的查询压力，可以将这一部分数据放入缓存中，直接从缓存中读取。除了一些像Redis等缓存外，还可以通过本地内存，作为缓存。下边将使用ConcurrentHashMap来实现本地缓存。

相关的技术：

• ConcurrentHashMap --数据存储，线程安全的map
• ScheduledExecutorService --线程定时调度服务
• TimerTask --定时任务
• lambda表达式

整体思路

1.用线程安全的ConcurrentHashMap来作为缓存数据的存储，
2.然后通过定时调度任务TimerTask，来实现控制缓存的有效时间，根据缓存设置的
  超时时间，来定时清除对应的 key，实现缓存过期
3.实现一些静态方法，来增加缓存、获取缓存等

定时任务也可也以用Timer来进行调度，但是Timer与ScheduledExecutorService相比有一些
缺陷，具体对比，可以另行查看。

1.多线程并行处理定时任务时，Timer运行多个TimeTask时，只要其中之一没有捕获
  抛出的异常其它任务便会自动终止运行，使用ScheduledExecutorService则没有这个问题
2.Timer内部是一个线程，任务1所需的时间超过了两个任务间的间隔时会导致问题
3.Timer执行周期任务时依赖系统时间

LocalCache整体结构 ​​​​​​

初始化数据

  /**
     * 默认缓存时长 单位s
     */
    private static final int DEFAULT_TIMEOUT = 3600;
    /**
     * 默认缓存容量
     */
    private static final int DEFAULT_SIZE = 1000;

    /**
     * 存储数据
     */
    private static final Map<String,Object> data;

    private static final ScheduledExecutorService executorService;

    //初始化
    static {
        data = new ConcurrentHashMap<>(DEFAULT_SIZE);
        executorService = new ScheduledThreadPoolExecutor(2);
    }
   /**
     * 私有化构造函数
     */
    private LocalCache(){}

删除缓存的定时任务

定时任务主要是实现TimerTask类中的run方法，传入对应的key，然后从缓存中移除对应的键值对，所以实现方式有三种：静态内部类、匿名内部类、以及lambda方式，选择熟悉的一种即可

//静态内部类
    static class CacheCleanTask extends TimerTask {

        private String key;

        private CacheCleanTask(String key){
            this.key = key;
        }

        public static CacheCleanTask cacheTask(String key){
            return  new CacheCleanTask(key);
        }

        @Override
        public void run() {
            //移除对应 key
            LocalCache.remove(key);
        }
    }

增加缓存

    /**
     * 增加缓存 默认有效时长
     * @param key
     * @param value
     */
    public static void put(String key, Object value){
        data.put(key,value);
        //定时器 调度任务，用于根据 时间 定时清除 对应key 缓存
        executorService.schedule(new TimerTask() {
            @Override
            public void run() {
                remove(key);
            }
        }, DEFAULT_TIMEOUT, TimeUnit.SECONDS);
    }

    /**
     * 增加缓存  并设置缓存时长 单位 s
     * @param key
     * @param value
     * @param timeout 缓存时长 单位s
     */
    public static void put(String key, Object value, int timeout){
        data.put(key, value);
        //lambda 替换匿名内部类
        executorService.schedule(() -> remove(key), timeout, TimeUnit.SECONDS);
    }

获取缓存

    /**
     * 获取缓存
     * @param key
     * @return
     */
    public static Object get(String key){
        return data.get(key);
    }

    /**
     * 获取当前缓存中 所有的key
     * @return
     */
    public static Set<String> cacheKeys(){
        return data.keySet();
    }

删除缓存

    /**
     * 删除缓存
     * @param key
     */
    public static void remove(String key){
        data.remove(key);
    }

    /**
     * 清空所有缓存
     */
    public static void clear(){
        if(size() > 0){
            data.clear();
        }
    }

测试方法就不贴了，其他更多相关方法的实现，可以看一下GitHub上源码的具体实现。

以上-