Java使用map实现带过期时间的缓存机制

package com.sunny.utils;

import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class SysCache {

    // 单例实例
    private static class Holder {
        private static final SysCache INSTANCE = new SysCache();
    }

    public static SysCache getInstance() {
        return Holder.INSTANCE;
    }

    // 缓存存储结构，Key为String，Value为包含值和过期时间的CacheEntry对象
    private final ConcurrentHashMap<String, CacheEntry> cacheMap = new ConcurrentHashMap<>();
    // 定时任务执行器
    private final ScheduledExecutorService  scheduledExecutorService;

    // 私有构造方法，初始化定时清理任务
    private SysCache() {
        scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
        // 每隔1秒执行一次清理任务
        scheduledExecutorService.scheduleAtFixedRate(this::cleanUp, 1, 1, TimeUnit.SECONDS);
        // 注册JVM关闭钩子以优雅关闭线程池
        Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown));
    }

    /**
     * 存入缓存
     * @param key 键
     * @param value 值
     */
    public void set(String key, Object value){
        cacheMap.put(key, new CacheEntry(value, -1));
    }

    /**
     * 存入缓存
     * @param key 键
     * @param value 值
     * @param expireTime 过期时间，单位毫秒
     */
    public void set(String key, Object value, long expireTime) {
        if (expireTime <= 0) {
            throw new IllegalArgumentException("expireTime must be greater than 0");
        }
        cacheMap.put(key, new CacheEntry(value, System.currentTimeMillis() + expireTime));
    }

    /**
     * 删除缓存
     * @param key 键
     */
    public void remove(String key) {
        cacheMap.remove(key);
    }

    /**
     * 缓存中是否包含键
     * @param key 键
     */
    public boolean containsKey(String key) {
        CacheEntry cacheEntry = cacheMap.get(key);
        if (cacheEntry == null) {
            return false;
        }
        if (cacheEntry.getExpireTime() < System.currentTimeMillis()) {
            remove(key);
            return false;
        }
        return true;
    }


    /**
     *获取缓存值
     * @param key 键
     */
    public Object get(String key) {
        CacheEntry cacheEntry = cacheMap.get(key);
        if (cacheEntry == null) {
            return null;
        }
        if (cacheEntry.getExpireTime() < System.currentTimeMillis()) {
            cacheMap.remove(key);
            return null;
        }
        return cacheEntry.getValue();
    }


    private static class CacheEntry {
        private final Object value;
        private final long expireTime;

        public CacheEntry(Object value, long expireTime) {
            this.value = value;
            this.expireTime = expireTime;
        }

        public Object getValue() {
            return value;
        }

        public long getExpireTime() {
            return expireTime;
        }
    }

    /**
     * 定时清理过期条目
     */
    private void cleanUp() {
        Iterator<Map.Entry<String, CacheEntry>> iterator = cacheMap.entrySet().iterator();
        long currentTime = System.currentTimeMillis();
        while (iterator.hasNext()) {
            Map.Entry<String, CacheEntry> entry = iterator.next();
            CacheEntry cacheEntry = entry.getValue();
            if (cacheEntry.expireTime < currentTime) {
                // 使用iterator移除当前条目，避免ConcurrentModificationException
                iterator.remove();
            }
        }
    }

    /**
     * 关闭线程池释放资源
     */
    private void shutdown() {
        scheduledExecutorService.shutdown();
        try {
            if (!scheduledExecutorService.awaitTermination(5, TimeUnit.SECONDS)) {
                scheduledExecutorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            scheduledExecutorService.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}