使用 ConcurrentHashMap 实现一个本地缓存服务,系统快多了!

>>强大,10k+点赞的 SpringBoot 后台管理系统竟然出了详细教程!

点击关注公众号,利用碎片时间学习

很多场景下,有些请求的数据,是不会经常改变的,这种时候,为了减少数据库的查询压力,可以将这一部分数据放入缓存中,直接从缓存中读取。除了一些像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整体结构

使用 ConcurrentHashMap 实现一个本地缓存服务,系统快多了!

初始化数据

  /**
     * 默认缓存时长 单位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上源码的具体实现。

https://github.com/liuyuanju7/Web-Crawler/tree/master/wangyiyun/src/main/java/com/liuyj/core/cache

来源:blog.csdn.net/qq_37176126/article/details/82837452

推荐:

最全的java面试题库

使用 ConcurrentHashMap 实现一个本地缓存服务,系统快多了!
PS:因为公众号平台更改了推送规则,如果不想错过内容,记得读完点一下“在看”,加个“星标”,这样每次新文章推送才会第一时间出现在你的订阅列表里。“在看”支持我们吧!

原文始发于微信公众号(Java笔记虾):使用 ConcurrentHashMap 实现一个本地缓存服务,系统快多了!