基于ConcurrentHashMap的本地缓存

爱被打了一巴掌 2021-11-16 08:50 410阅读 0赞

# 基于ConcurrentHashMap的本地缓存 #

--------------------

在系统中，有些数据，数据量小，但是访问十分频繁（例如国家标准行政区域数据），针对这种场景，需要将数据搞到应用的本地缓存中，以提升系统的访问效率，减少无谓的数据库访问（数据库访问占用数据库连接，同时网络消耗比较大），但是有一点需要注意，就是缓存的占用空间以及缓存的失效策略

### 代码实现 ###

package com.mine.localcache;
    
    import java.util.Date;
    import java.util.Map;
    import java.util.Timer;
    import java.util.TimerTask;
    import java.util.concurrent.ConcurrentHashMap;
    
    /** * ****************************** * createTime: 2019/7/15 9:56 * description: 基于ConcurrentHashMap的本地缓存解决方案 * version: V1.0 * ****************************** */
    public class LocalCache { 
    
        /** * 默认有效时长,单位:秒 */
        private static final int DEFUALT_TIMEOUT = 3600 * 1000;
    
        private static final long SECOND_TIME = 1000;
    
        private static final Map<String, Object> map;
    
        private static Timer timer;
    
        /** * 初始化 */
        static { 
            timer = new Timer();
            map = new ConcurrentHashMap<>();
        }
    
        /** * 私有构造函数,工具类不允许实例化 */
        private LocalCache() { }
    
        /** * 清除缓存任务类 */
        static class CleanWorkerTask extends TimerTask { 
    
            private String key;
    
            public CleanWorkerTask(String key) { 
                this.key = key;
            }
    
            public void run() { 
                LocalCache.remove(key);
            }
        }
    
        /** * 增加缓存 * * @param key * @param value */
        public static void put(String key, Object value) { 
            map.put(key, value);
            timer.schedule(new CleanWorkerTask(key), DEFUALT_TIMEOUT);
        }
    
        /** * 增加缓存 * * @param key * @param value * @param timeout 有效时长 */
        public static void put(String key, Object value, int timeout) { 
            map.put(key, value);
            timer.schedule(new CleanWorkerTask(key), timeout * SECOND_TIME);
        }
    
        /** * 增加缓存 * * @param key * @param value * @param expireTime 过期时间 */
        public static void put(String key, Object value, Date expireTime) { 
            map.put(key, value);
            timer.schedule(new CleanWorkerTask(key), expireTime);
        }
    
    
        /** * 批量增加缓存 * * @param m */
        public static void putAll(Map<String, Object> m) { 
            map.putAll(m);
    
            for (String key : m.keySet()) { 
                timer.schedule(new CleanWorkerTask(key), DEFUALT_TIMEOUT);
            }
        }
    
        /** * 批量增加缓存 * * @param m */
        public static void putAll(Map<String, Object> m, int timeout) { 
            map.putAll(m);
    
            for (String key : m.keySet()) { 
                timer.schedule(new CleanWorkerTask(key), timeout * SECOND_TIME);
            }
        }
    
        /** * 批量增加缓存 * * @param m */
        public static void putAll(Map<String, Object> m, Date expireTime) { 
            map.putAll(m);
    
            for (String key : m.keySet()) { 
                timer.schedule(new CleanWorkerTask(key), expireTime);
            }
        }
    
        /** * 获取缓存 * * @param key * @return */
        public static Object get(String key) { 
            return map.get(key);
        }
    
        /** * 查询缓存是否包含key * * @param key * @return */
        public static boolean containsKey(String key) { 
            return map.containsKey(key);
        }
    
        /** * 删除缓存 * * @param key */
        public static void remove(String key) { 
            map.remove(key);
        }
    
        /** * 删除缓存 * * @param o */
        public static void remove(Object o) { 
            map.remove(o);
        }
    
        /** * 返回缓存大小 * * @return */
        public static int size() { 
            return map.size();
        }
    
        /** * 清除所有缓存 * * @return */
        public static void clear() { 
            if (size() > 0) { 
                map.clear();
            }
    
            // 取消延时任务,重新创建Timer
            timer.cancel();
            timer = new Timer();
        }
    }

### 测试Demo ###

public class TestDemo { 
    
        public static void main(String[] args) throws InterruptedException { 
            for (int i = 0; i < 20000; i++) { 
                LocalCache.put(i + "", "test for " + i , 20);
            }
    
            System.out.println("ok");
    
            Thread.sleep(10 * 1000);
    
            for (int i = 0; i < 20000; i++) { 
                System.out.println(LocalCache.get(i + ""));
            }
    
            Thread.sleep(15 * 1000);
    
            for (int i = 0; i < 20000; i++) { 
                System.out.println(LocalCache.get(i + ""));
            }
        }
    }

### 总结分析 ###

该缓存是基于ConcurrentHashMap配合Timer实现的本地缓存策略，但是它有其瓶颈，比如：
    LRU：Least Recently Used，最近最少使用 算法实现等
    都均未实现，不过可以用作学习和参考使用
    
    生产级别推荐使用：Guava cache构建本地缓存