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，功能很全，可以用作数据库到前端页面中间的缓存模块，推荐使用。

 

 世间之事莫强求，凡事太尽，缘分势必早尽。