JAVA中基于Map实现缓存工具类

    上一篇博客是基于map实现了一个简单的缓存工具类，但实际开发过程中我们会发现，我们的内存空间是有限的，当缓存占用的空间达到上限，我们就应该将超过上限需要淘汰部分的缓存数据清除掉，从而达到缓存空间的优化。

    常见的淘汰策略有：FIFO、LRU、LFU，这里我根据老师的讲解，在上一往篇的基础之上，加入了FIFO淘汰策略的支持。

    感兴趣的同学一起来学习一下，继续贴代码……

package com.study.map;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 基于map的缓存工具类, 带FIFO策略
 * @author tongke
 * @email [e-mail]
 * @create 2020-07-20 21:53
 */
public class FIFOCacheProvider {

    //存放缓存的集合
    private Map<String, CacheData> cacheDatas = null;

    //定时器线程池，用于消除过期缓存
    private final static ScheduledThreadPoolExecutor EXECUTOR = new ScheduledThreadPoolExecutor(5);
    //FIFO
    private static int MAX_CACHE_SIZE = 0;
    //
    private final float LOAD_FACTORY = 0.75f;

    public FIFOCacheProvider(int maxCacheSize){
        MAX_CACHE_SIZE = maxCacheSize;

        int capacity = (int) (Math.ceil(MAX_CACHE_SIZE / LOAD_FACTORY) + 1);
        cacheDatas = new LinkedHashMap<String, CacheData>(capacity, LOAD_FACTORY, false){
            @Override
            protected boolean removeEldestEntry(Map.Entry<String, CacheData> eldest) {
                return size() > MAX_CACHE_SIZE;
            }
        };
    }

    /**
     * 1 获取缓存数据
     * @param key
     * @param <T>
     * @return
     */
    public synchronized <T> T get(String key){
        CacheData cacheData = cacheDatas.get(key);
        return cacheData == null ? null : (T) cacheData.data;
    }


    //2 设置

    /**
     * 设置缓存 永不失效
     * @param key
     * @param value
     */
    public synchronized void put(String key, Object value){
        this.put(key, value, -1L);
    }

    /**
     * 设置缓存，需要设置超时时间
     * @param key
     * @param value
     * @param expire    时间单位：毫秒，-1表示永不超时
     */
    public synchronized void put(String key, Object value, Long expire){
        //清除原数据
        cacheDatas.remove(key);
        if(expire > 0){     //大于0才设置
            EXECUTOR.schedule(new Runnable() {
                @Override
                public void run() {
                    //过期后清除缓存
                    synchronized (this){
                        cacheDatas.remove(key);
                    }
                }
            }, expire, TimeUnit.MILLISECONDS);
            cacheDatas.put(key, new CacheData(value, expire));
        }else {
            cacheDatas.put(key, new CacheData(value, -1L));
        }

    }

    /**
     * 3 删除
     * @param key
     * @param <T>
     * @return
     */
    public synchronized <T> T remove(String key){
        CacheData cacheData = cacheDatas.remove(key);
        return cacheData == null ? null : (T) cacheData.data;
    }

    /**
     * 4 总数
     * @return
     */
    public synchronized int size(){
        return cacheDatas.size();
    }

    /**
     * 缓存实体类
     */
    public class CacheData{
        //缓存数据
        public  Object data;
        //失效时间
        public Long expire;

        public CacheData(Object data, Long expire) {
            this.data = data;
            this.expire = expire;
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, CacheData> entry: cacheDatas.entrySet()){
            sb.append(entry.getKey()).append("=").append(entry.getValue().data).append("\n");
        }
        return sb.toString();
    }
}

测试类：

package com.study.map;

import org.junit.jupiter.api.Test;

import java.util.UUID;

/**
 * @author tongke
 * @email [e-mail]
 * @create 2020-07-20 22:44
 */
public class FIFOCacheTest {

    @Test
    public void test(){
        FIFOCacheProvider provider = new FIFOCacheProvider(10);
        for (int i = 0; i < 15; i++) {
            provider.put("id"+i, UUID.randomUUID());
        }
        System.out.println("缓存的大小："+ provider.size());
        System.out.println("缓存的数据：\n"+provider.toString());
    }
}

输出的结果：

缓存的大小：10
缓存的数据：
id5=b3f6a386-63c9-4998-9bb6-645357e8a4e5
id6=09ccca0c-fe21-4d4d-961a-b364eca9dc31
id7=82d35aba-056a-412e-89ec-65438e750d73
id8=dd99d745-6c21-486c-8370-5f78e5a78ea4
id9=3d6fb3b6-d762-458b-83cd-2ac6bad8bb85
id10=715a376f-3944-47f2-99a6-7c6b45a844df
id11=38a14eac-1f3b-4946-9e40-535ca60616b7
id12=fbc7c745-3dba-4c90-b653-4af560914d9d
id13=ddfcc7ff-06a7-42c6-8d55-fc4431e45dfa
id14=839b264f-aaec-45ef-8e13-fca6cf0c767d

从输出的结果我们可以看出，我们往缓存中加入了15条数据，但我们的缓存空间只能容纳10条，那么我们的FIFO策略会把先插入的id0~id4这5条数据淘汰掉。

本文地址：https://blog.csdn.net/tongkp/article/details/107477317