当前位置: 首页>后端>正文

利用DelayQueue实现一个定时缓存

利用DelayQueue实现一个可定时的缓存,使用单例模式,以便调用的时候都是同一个对象,定时器用DelayQueue来实现,还可以支持多线程情况下的调用

DelayQueue简介

DelayQueue是一个无界的BlockingQueue,用于放置实现了Delayed接口的对象,其中的对象只能在其到期时才能从队列中取走。这种队列是有序的,即队头对象的延迟到期时间最长。注意:不能将null元素放置到这种队列中。
因为DelayQueue是基于PriorityQueue实现的,PriorityQueue底层是一个堆,可以按时间排序,所以等待队列本身只需要维护根节点的一个定时器就可以了,而且插入和删除都是时间复杂度都是logn,资源消耗很少,作为一个缓存的定时装置是非常适合的
使用 DelayQueue 需要传入一个Delayed对象,要实现两个方法
1 getDelay(TimeUnit unit) 表示当前对象关联的延时,在本例中表示生存时间
2 compareTo(Delayed o) 堆在进行删除和插入时需要进行对比,所以要传入一个比较器

实例展示

public class ExpiryMap {

    private static final Logger log = LoggerFactory.getLogger(ExpiryMap.class);

    private ExpiryMap() {
    }
    private static volatile ExpiryMap expiryMap;
    /**
     * 键值对集合
     */
    private final static Map<String, Object> map = new HashMap<>();
    /**
     * 使用阻塞队列中的等待队列,因为DelayQueue是基于PriorityQueue实现的,而PriorityQueue底层是一个最小堆,可以按过期时间排序,
     * 所以等待队列本身只需要维护根节点的一个定时器就可以了,而且插入和删除都是时间复杂度都是logn,资源消耗很少
     */
    private final static DelayQueue<DelayData<String>> delay = new DelayQueue<>();

    //使用单例模式,加上双重验证,可适用于多线程高并发情况
    public static  ExpiryMap getInstance() {
        if (expiryMap == null) {
            synchronized (ExpiryMap.class) {
                if (expiryMap == null) {
                    expiryMap = new ExpiryMap();
                    //生成一个线程扫描等待队列的值
                    ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
                    scheduledExecutorService.execute(()->{
                        while (true) {
                            try {
                                //此方法是阻塞的,没有到过期时间就阻塞在这里,直到取到数据
                                DelayData<String> take = delay.take();
                                map.remove(take.data);
                            } catch (InterruptedException e) {
                                log.error("ExpiryMap线程被打断");
                            }
                        }
                    });
                }
            }
        }
        return expiryMap;
    }

    /**
     * 添加缓存
     *
     * @param key    键
     * @param data   值
     * @param expire 过期时间,单位:毫秒, 0表示无限长
     */
    public void put(String key, Object data, long expire) {
        map.put(key,data);
        //当等于0时,就不把过期时间放进队列里了,值在代码运行期间会一直存在
        if (expire != 0) {
            delay.offer(new DelayData<>(key, System.currentTimeMillis() + expire));
        }
    }

    /**
     * 读取缓存
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return map.get(key);
    }

    /**
     * 清除缓存
     *
     * @param key 键
     * @return 值
     */
    public Object remove(String key) {
        return map.remove(key);
    }

    /**
     * 查询当前缓存的键值对数量
     * @return 数量
     */
    public int size() {
        return map.size();
    }
    //试下Delayed接口
    static class DelayData<T> implements Delayed{
        private T data;
        //到期时间
        private long expire;

        public DelayData(T data, long expire) {
            this.data = data;
            this.expire = expire;
        }

        //如果返回小于0就代表过期了
        @Override
        public long getDelay(TimeUnit unit) {
            //expire是过期时的时间
            long diffTime= expire- System.currentTimeMillis();
            return unit.convert(diffTime,TimeUnit.MILLISECONDS);
        }

        @Override
        public int compareTo(Delayed o) {
            return (int)(this.expire - ((DelayData<T>) o).getExpire());
        }

        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }

        public long getExpire() {
            return expire;
        }

        public void setExpire(long expire) {
            this.expire = expire;
        }
    }

写一个测试方法

分别像缓存中放入3个值,时间分别是1s,2s,3s,每过1s,打印下结果

    public static void main(String[] args) throws InterruptedException {
        ExpiryMap instance = getInstance();
        instance.put("key1","key1",1000);
        instance.put("key2","key2",2000);
        instance.put("key3","key3",3000);
        System.out.println(instance.get("key1"));
        System.out.println(instance.get("key2"));
        System.out.println(instance.get("key3"));
        Thread.sleep(1000);
        System.out.println("-----------------");
        System.out.println(instance.get("key1"));
        System.out.println(instance.get("key2"));
        System.out.println(instance.get("key3"));
        Thread.sleep(1000);
        System.out.println("-----------------");
        System.out.println(instance.get("key1"));
        System.out.println(instance.get("key2"));
        System.out.println(instance.get("key3"));
        Thread.sleep(1000);
        System.out.println("-----------------");
        System.out.println(instance.get("key1"));
        System.out.println(instance.get("key2"));
        System.out.println(instance.get("key3"));
    }

输出结果

可以看出,缓存每过一秒就会被删除一个元素,删除时间是根据传入的过期时间清除的

key1
key2
key3
-----------------
null
key2
key3
-----------------
null
null
key3
-----------------
null
null
null

https://www.xamrdz.com/backend/3xk1934931.html

相关文章: