public interface LocalCache<V> {
    /**
     * 插入數(shù)據(jù)，數(shù)據(jù)永久有效
     */
    boolean put(String key, V value);

    /**
     * 插入數(shù)據(jù)，在指定時(shí)間內(nèi)生效
     */
    boolean put(String key, V value, int seconds);

    /**
     * 是否包含指定的key
     */
    boolean containKey(String key);

    /**
     * 獲取指定Key的值
     */
    V get(String key);

    /**
     * 從緩存中移除key對(duì)應(yīng)的數(shù)據(jù)
     */
    void remove(String key);

    void shutdownNow();
}

public class DefaultLocalCache<V> implements LocalCache<V> {
    // 默認(rèn)容量
    private static final int DEFAULT_CAPACITY = 1024;
    private static final int MAX_CAPACITY = 100000;

    private static final int DEFAULT_THREAD_SIZE = 1;

    private final int maxSize;

    //數(shù)據(jù)map
    private volatile ConcurrentHashMap<String,V> dataMap;
    //過(guò)期時(shí)間
    private final ConcurrentHashMap<String,Long> timeOutMap;

    //定時(shí)任務(wù)
    private final ScheduledExecutorService executorService;

    public DefaultLocalCache() {
        maxSize = MAX_CAPACITY;
        dataMap = new ConcurrentHashMap<>(DEFAULT_CAPACITY);
        timeOutMap = new ConcurrentHashMap<>(DEFAULT_CAPACITY);
        executorService = new ScheduledThreadPoolExecutor(DEFAULT_THREAD_SIZE) ;
    }

    public DefaultLocalCache(int size) {
        maxSize = size;
        dataMap = new ConcurrentHashMap<>(DEFAULT_CAPACITY);
        timeOutMap = new ConcurrentHashMap<>(DEFAULT_CAPACITY);
        executorService = new ScheduledThreadPoolExecutor(DEFAULT_THREAD_SIZE) ;
    }

    @Override
    public boolean put(String key, V value) {
        //檢查容量
        if(checkCapacity()){
            dataMap.put(key,value);
            return true;
        }
        return false;
    }



    @Override
    public boolean put(String key, V value, int seconds) {
        if(checkCapacity()){
            dataMap.put(key,value);
            if(seconds >= 0){
                timeOutMap.put(key,getTimeOut(seconds));
                ClearTask task = new ClearTask(key);
                executorService.schedule(task, seconds, TimeUnit.SECONDS);
            }
        }
        return false;
    }

 ......

    class ClearTask implements Runnable{
        private String key;

        public ClearTask(String key){
            this.key = key;
        }
        @Override
        public void run() {
            //判斷緩存中是否有key
            if(timeOutMap.contains(key)){
                //獲取失效時(shí)間
                Long expire = timeOutMap.get(key);
                //如果失效時(shí)間大于0，并且比當(dāng)前時(shí)間小，則刪除緩存
                if(expire > 0){
                    long now = System.currentTimeMillis();
                    if(now >= expire){
                        remove(key);
                    }
                }
            }
        }
    }
}