基于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构建本地缓存