Map实现带失效时间的缓存工具类

Posted 2023-04-04

参考技术A import java.util.Iterator;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

public class CacheWithExpireUtil

// 缓存map

    private static MapcacheMap =new ConcurrentHashMap();

// 缓存有效期map

    private static MapexpireTimeMap =new ConcurrentHashMap();

/**

    * 获取指定的value，如果key不存在或者已过期，则返回null

*

    * @param key

    * @return

    */

    public static Object get(String key)

if (!cacheMap.containsKey(key))

return null;



if (expireTimeMap.containsKey(key))

if (expireTimeMap.get(key) < System.currentTimeMillis()) // 缓存失效，已过期

                return null;





return cacheMap.get(key);



/**

    * @param key

    * @param

    * @return

    */

    public static T getT(String key)

Object obj =get(key);

return obj ==null ?null : (T) obj;



/**

    * 设置value（不过期）

    *

    * @param key

    * @param value

    */

    public static void set(String key, Object value)

cacheMap.put(key, value);



/**

    * 设置value

*

    * @param key

    * @param value

    * @param second 过期时间（秒）

    */

    public static void set(final String key, Object value,int second)

final long expireTime = System.currentTimeMillis() + second *1000;

cacheMap.put(key, value);

expireTimeMap.put(key, expireTime);

if (cacheMap.size() >2) // 清除过期数据

            new Thread(new Runnable()

@Override

                public void run()

// 此处若使用foreach进行循环遍历，删除过期数据，会抛出java.util.ConcurrentModificationException异常

                    Iterator> iterator =cacheMap.entrySet().iterator();

while (iterator.hasNext())

Map.Entry entry = iterator.next();

if (expireTimeMap.containsKey(entry.getKey()))

long expireTime =expireTimeMap.get(key);

if (System.currentTimeMillis() > expireTime)

iterator.remove();

expireTimeMap.remove(entry.getKey());









).start();





/**

    * key是否存在

    *

    * @param key

    * @return

    */

    public static boolean isExist(String key)

return cacheMap.containsKey(key);



/**

    * 清除缓存

    *

    * @param key

    */

    public static void remove(String key)

cacheMap.remove(key);



public static void main(String[] args)

CacheWithExpireUtil.set("testKey_1","testValue_1");

CacheWithExpireUtil.set("testKey_2","testValue_2",10);

CacheWithExpireUtil.set("testKey_3","testValue_3");

CacheWithExpireUtil.set("testKey_4","testValue_4",1);

Object testKey_2 = CacheWithExpireUtil.get("testKey_2");

System.out.println(testKey_2);

ThreadLocal工具类做缓存（线程隔离思想）

public class ThreadLocalCache {

    private static ThreadLocal<Map<String, Object>> cache=new ThreadLocal<Map<String,Object>>();

    /**
     * 从ThreadLocal里获取缓存的值
     * @param key 要获取的数据的KEY
     * @return 要获取的值
     */
    public static Object getCache(String key) {
        Map<String, Object> map = cache.get();
        if(isCacheIsNull())
            return null;
        if(map.containsKey(key)){
            return map.get(key);
        }
        return null;
    }

    /**
     * 向ThreadLocal缓存值
     * @param key 要缓存的KEY
     * @param value 要缓存的VALUE
     */
    public static void set(String key,Object value) {
        if(!isCacheIsNull()){
            cache.get().put(key, value);
        } else{
            Map<String, Object> vmap = new HashMap<String, Object>();
            vmap.put(key, value);
            cache.set(vmap);
        }
    }

    /**
     * 根据KEY移除缓存里的数据
     * @param key
     */
    public static void removeByKey(String key){
        if(!isCacheIsNull()){
            cache.get().remove(key);
        }
    }

    /**
     * 移除当前线程缓存
     * 用于释放当前线程threadlocal资源
     */
    public static void remove(){
        cache.remove();
    }

    private static boolean isCacheIsNull(){
        return  cache.get()==null;
    }


    public static String cacheToString() {
        return isCacheIsNull() ? null : cache.get().toString();
    }
}

工具类