JAVA實現延時過期MAP 支持自定義過期觸發事件

如題，直接上代碼：

import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 實現延時過期MAP集合 支持自定義過期觸發事件
 * 
 * @ClassName: BaseExpireMap
 * @Description: TODO
 * @author: wangs
 * @date: 2017-12-25 上午9:59:04
 * @param <K>
 * @param <V>
 */
public abstract class BaseExpireMap<K, V> {
    protected static final Logger logger = LoggerFactory.getLogger(BaseExpireMap.class);
    private long expTime = 0L;
    private TimeUnit unit = null;
    /**
     * 線程安全的map容器
     */
    ConcurrentHashMap<K, V> expireMap = null;
    /**
     * 控制過期時間
     */
    ConcurrentHashMap<K, Long> delayMap = null;
    
    /**
     * 將map提供給外部程序操作
     * @Title: getDataMap 
     * @Description: TODO
     * @return
     * @return: ConcurrentHashMap<K,V>
     */
    public ConcurrentHashMap<K, V> getDataMap(){
        return this.expireMap;
    }

    public BaseExpireMap(long expTime, TimeUnit unit) {
        expireMap = new ConcurrentHashMap<K, V>();
        delayMap = new ConcurrentHashMap<K, Long>();
        this.expTime = expTime;
        this.unit = unit;
        // 啟動監聽線程
        BaseExpireCheckTask task = new BaseExpireCheckTask(expireMap, delayMap) {
            @Override
            protected void expireEvent(K key,V val) {
                baseExpireEvent(key,val);
            }
        };
        task.setDaemon(false);
        task.start();
    }

    /**
     * 過期事件 子類實現
     * 
     * @Title: baseExpireEvent
     * @Description: TODO
     * @param key
     * @return: void
     */
    protected abstract void baseExpireEvent(K key,V val);

    public V put(K key, V val) {
        delayMap.put(key, getExpireTime());
        return expireMap.put(key, val);
    }

    public V remove(K key) {
        return expireMap.remove(key);
    }
    
    public V get(K key){
        return expireMap.get(key);
    }

    private Long getExpireTime() {
        return unit.toMillis(expTime) + System.currentTimeMillis();
    }

    public static void main(String[] args) {
        System.out.println(TimeUnit.SECONDS.toMinutes(120));
        System.out.println(TimeUnit.MICROSECONDS.toMillis(120));
        System.out.println(TimeUnit.MILLISECONDS.toMillis(120));
    }

    /**
     * 掃描線程 定期移除過期元素並觸發過期事件
     * 
     * @ClassName: BaseExpireCheckTask
     * @Description: TODO
     * @author: wangs
     * @date: 2017-12-25 上午9:59:18
     */
    private abstract class BaseExpireCheckTask extends Thread {
        ConcurrentHashMap<K, Long> delayMap = null;
        ConcurrentHashMap<K, V> expireMap = null;

        public BaseExpireCheckTask(ConcurrentHashMap<K, V> expireMap, ConcurrentHashMap<K, Long> delayMap) {
            this.delayMap = delayMap;
            this.expireMap = expireMap;
        }

        protected abstract void expireEvent(K key,V val);

        public void run() {
            Iterator<K> it = null;
            K key = null;
            while (true) {
                if (delayMap != null && !delayMap.isEmpty()) {
                    it = delayMap.keySet().iterator();
                    while (it.hasNext()) {
                        key = it.next();
                        if (delayMap.get(key) <= System.currentTimeMillis()) {// 元素超時
                            // 觸發回調
                            expireEvent(key,expireMap.get(key));
                            // 移除
                            it.remove();
                            expireMap.remove(key);
                            delayMap.remove(key);
                        }
                    }
                }
                try {
                    TimeUnit.MILLISECONDS.sleep(200);
                } catch (InterruptedException e) {
                    logger.error(e.getMessage());
                }
            }
        }
    }
}

上面是一個通用的延遲過期MAP容器，由兩個線程安全的map集合和一個掃描線程組成，該容器會定時移除超時的元素並在移除時觸發指定事件expireEvent，該方法的兩個參數Key和val分別代表過期元素的鍵值，定義了元素過期時的觸發事件，等待子類實現。

下面是一個使用實例：

import java.util.concurrent.TimeUnit;

import com.montnets.kafka.Producer;
import com.montnets.smsverify.bean.VerifyAccountSeatBean;
import com.montnets.smsverify.common.StaticValues;
import com.montnets.smsverify.netty.utils.GsonUtil;

/**
 * 進退坐席緩存
 * 
 * @ClassName: SeatCache
 * @Description: 單例
 * @author: wangs
 * @date: 2017-12-25 下午2:23:21
 */
public class SeatCache extends BaseExpireMap<String, VerifyAccountSeatBean> {
    private static SeatCache instance = null;
    private static Producer producer = null;
    static long expTime = 0L;
    static TimeUnit unit = null;

    private SeatCache(long expTime, TimeUnit unit) {
        super(expTime, unit);
    }

    public synchronized static void init(long expTime, TimeUnit unit) {
        SeatCache.expTime = expTime;
        SeatCache.unit = unit;
        if (instance == null) {
            instance = new SeatCache(expTime, unit);
            producer = new Producer();
        }
    }

    public synchronized static SeatCache getInstance() {
        if (instance == null) {
            if (unit == null)
                throw (new IllegalArgumentException("please call init at first"));
            instance = new SeatCache(expTime, unit);
            producer = new Producer();
        }
        return instance;
    }

    
    /**
     * 過期事件
     */
    @Override
    protected void baseExpireEvent(String key, VerifyAccountSeatBean bean) {
        if(bean!=null)
            bean.setIsManual(1); //非手動退坐席
        //更新
        updateOffOnlie(bean);
        //寫kafka
        send2kafka(bean);
    }

    /**
     * 退坐席之前更新時間標記
     * @Title: updateOffOnlie 
     * @Description: TODO
     * @param bean
     * @return: void
     */
    public static void updateOffOnlie(VerifyAccountSeatBean bean) {
        if (bean != null) {
            long now = System.currentTimeMillis();
            // 退坐席時間
            bean.setOutSeatTime(now);
            // 在線時長
            bean.setOnlineTime(now - bean.getInSeatTime());
        }
    }

    /**
     * 退坐席時將數據寫入kafka
     * 
     * @Title: send2kafka
     * @Description: TODO
     * @param topic
     * @param bean
     * @return: void
     */
    public static void send2kafka(VerifyAccountSeatBean bean) {
        if (bean == null)
            return;
        producer.send(StaticValues.SEAT_DATA, GsonUtil.toJson(bean));
    }
}

推薦一個很強大的過期緩存第三方工具包，com.google.common.cache.Cache ，它提供多種回收策略，如基於創建時間或最后一次訪問時間計時回收、基於對象容量大小回收、按照命中率使用LRU算法回收等，並且一樣可以自定義過期回收觸發事件（寫這個工具的時候我還不知道有這么個強大的玩意 - -）；另外還提供命中統計的API，功能很全，可以用作數據庫到前端頁面中間的緩存模塊，推薦使用。

 

 世間之事莫強求，凡事太盡，緣分勢必早盡。