实现简单的内存缓存

前言

在上一篇文章中,我们详细介绍了缓存的一些理论知识,相信大家对于缓存的概念不会太过于陌生了

为了更进一步的认识缓存,接下来我们将沿着缓存的一些理论知识基于java容器类来实现一个简单的内存缓存工具

实现内存缓存的目的有以下两点

• 掌握内存缓存的关键特性的实现策略

• 了解如何设计功能完善的内存缓存工具

回顾和推理

在实现内存缓存工具之前,我们先回顾一下缓存具备的一些特点,还要尝试着去推理缓存的实现方案

缓存具备的特点

• 设置存活时间(过期策略)

  缓存通常需要设置有效期,过期后应当失效

  常见的过期策略有：定时、定期、惰性失效

• 空间占用有限(淘汰策略)

  缓存占用有空间上限,超过上限需淘汰部分缓存数据

  常见的淘汰策略有：FIFO、LRU、LFU

• 支持并发更新

  缓存需要支持并发的读取和写入

推理缓存的实现方案

我们不妨大胆地猜测一下

什么样的数据结构比较适合存储缓存中的数据

什么样的数据结构可以通过一个特定的规则从缓存中获取数据

什么样的数据结构查询和存储的效率更快

我们将JDK提供的工具包常见的数据结构列举出来,然后使用排除法将不合适的一个个挑出来

• 数组

  数组查询数据和插入数据的时候需要下标,我们在使用缓存的时候还得特地去维护一个下标

  才知道这个数据在哪里

• 队列

  先进先出,没有特定的规则去获取数据

• 栈

  先进后出,没有特定的规则去获取数据

• 链表

  链表在插入的时候效率挺高的,改变下指针就好了

  但是在查询时需要通过规则遍历去判断才能找到缓存,这样效率会低了点

• 树

  树是有序的数据结构,那么在查询的时候效率会非常快,不需要全部遍历

  可是缓存数据的规则不可能是数字啊,如果还需要我们自己去维护一个数字的话那还不如用数组算了

• 键值对

  key = val

  通过key设置val,通过key查询val

  这种数据结构合适存储缓存,我们可以将缓存的规则定义成一个key

  然后无论是更新还是查询缓存都通过这个key去操作

实操

实现内存缓存的工具类,需要完成以下三个指标

• 支持设置缓存、获取缓存、删除缓存
• 支持过期策略,设置key的存活时间
• 支持FIFO淘汰策略,缓存满了以后需要从前往后淘汰key

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author 昊天锤
 * @date 2020/8/5 0005 15:29
 * @description 基于Map实现一个内存缓存工具类
 */
@Slf4j
public class MyCache {

    /**
     * 存放缓存的数据结构
     */
    private Map<String, CacheData> cacheDataMap;

    /**
     * 定时器线程池-用于定期去清除缓存
     */
    private ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(5);

    /**
     * 缓存大小
     */
    private int maxCacheSize;

    /**
     * 负载因子
     */
    private static final float LOAD_FACTORY = 0.75f;

    public MyCache(int maxCacheSize) {
        this.maxCacheSize = maxCacheSize;
        // 根据 cacheSize 和填充因子计算cacheDataMap的容量
        int capacity = (int) (Math.ceil(maxCacheSize / LOAD_FACTORY) + 1);

        // 利用LinkedHashMap的淘汰策略,FIFO的特性
        cacheDataMap = new LinkedHashMap<String, CacheData>(capacity, LOAD_FACTORY) {
            /**
             * 重写LinkedHashMap的淘汰策略
             * 如果LinkedHashMap的大小超过了maxCacheSize就淘汰掉最先保存的那个key
             * */
            @Override
            protected boolean removeEldestEntry(Map.Entry<String, CacheData> eldest) {
                return this.size() > MyCache.this.maxCacheSize;
            }
        };
    }


    /**
     * 获取缓存
     *
     * @param key 缓存规则
     */
    public <T> T get(String key) {
        return (T) Optional.ofNullable(cacheDataMap.get(key)).map(CacheData::getObject).orElse(null);
    }

    /**
     * 设置缓存
     *
     * @param key 缓存规则
     * @param val 需要存储的数据
     */
    public void put(String key, Object val) {
        put(key, val, -1L);
    }

    /**
     * 设置缓存及失效时间
     *
     * @param key    缓存规则
     * @param val    需要存储的数据
     * @param expire 缓存失效时间 -1则代表用不失效
     */
    public void put(String key, Object val, Long expire) {
        CacheData cacheData = new CacheData();
        cacheData.setObject(val);
        cacheData.setExpire(expire);
        cacheDataMap.put(key, cacheData);

        // 定时清除缓存
        if (expire != -1) {
            scheduledExecutorService.schedule(() -> {
                remove(key);
                log.info("过期时间到,定时删除缓存数据.key={}", key);
            }, expire, TimeUnit.MILLISECONDS);
        }
    }

    /**
     * 删除缓存
     *
     * @param key 缓存规则
     */
    public void remove(String key) {
        cacheDataMap.remove(key);
    }

    /**
     * 获取缓存大小
     */
    public int size() {
        return cacheDataMap.size();
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        this.cacheDataMap.forEach((k, v) -> stringBuilder.append(k).append("=").append(v.getObject()).append("\r\n"));
        return stringBuilder.toString();
    }
}

/**
 * @author 昊天锤
 * @date 2020/8/5 0005 15:29
 * @description 缓存载体
 */
@Data
class CacheData {

    /**
     * 缓存数据
     */
    private Object object;

    /**
     * 失效时间
     */
    private Long expire;
}

/**
 * @author 昊天锤
 * @date 2020/8/5 0005 15:29
 * @description 测试验证
 */
class Test {


    public static void main(String[] args) throws InterruptedException {
        // 构建一个缓存大小为5的缓存工具类
        MyCache myCache = new MyCache(5);

        // todo 缓存数据取用数据验证
        myCache.put("key1", new Object());
        System.out.println("key1 = " + myCache.get("key1"));


        // todo 过期策略验证
        myCache.put("key1", new Object(), 1000L);
        System.out.println("一秒钟之前 key1 = " + myCache.get("key1"));
        TimeUnit.MILLISECONDS.sleep(1010);
        System.out.println("一秒钟之后 key1 = " + myCache.get("key1"));

        myCache.remove("key1");

        // todo FIFO淘汰策略验证
        // 循环插入6个缓存值,但是缓存大小只有5,理应根据FIFO淘汰掉key=1的值
        for (int i = 1; i <= 6; i++) {
            myCache.put(String.valueOf(i), i);
        }
        System.out.println(myCache.toString());
    }
}

附上测试验证的运行结果

该缓存工具类可以实现：设置缓存、获取缓存、删除缓存、过期策略、FIFO淘汰策略

哈哈,看完代码后的你,是不是感觉很简单.嗯！没错,这确实是一个比较简单的内存缓存工具类

下一篇文章将介绍几个比较常见的内存缓存框架

Guava Cache

Ehcache

Caffeine