并发编程学习笔记（二十二、DelayQueue源码分析）

目录：

• 什么是DelayQueue
• 如何使用DelayQueue
• 总结

什么是DelayQueue

DelayQueue是一个支持延时获取元素的无界阻塞队列，队列使用PriorityQueue来实现。

队列中的元素必须实现Delayed接口，在创建元素时可以指定多久才能从队列中获取当前元素，只有在延迟期满时才能从队列中提取元素。

DelayQueue非常有用，可以运用在以下两个应用场景：

• 缓存系统的设计：使用DelayQueue保存缓存元素的有效期，使用一个线程循环查询DelayQueue，一旦能从DelayQueue中获取元素时，就表示有缓存到期了。
• 定时任务调度：使用DelayQueue保存当天要执行的任务和执行时间，一旦从DelayQueue中获取到任务就开始执行，比如Timer就是使用DelayQueue实现的。

如何使用DelayQueue

既然上面说到了DelayQueue可以用于缓存系统的设计，那么我这里的demo就来模拟一下上面的场景。

使用DelayQueue保存缓存元素的有效期，使用一个线程循环查询DelayQueue，一旦能从DelayQueue中获取元素时，就表示有缓存到期了

1、首先有个CacheData，实现Delayed接口，用作DelayQueue的数据源。

/**
 * 缓存数据源
 *
 * @author zhoude
 * @date 2020/6/29 21:09
 */
public class CacheData implements Delayed {

    /**
     * 缓存过期时间，<= 0表示已过期
     */
    private long remaining;

    /**
     * 缓存数据的key
     */
    private String key;

    /**
     * 缓存数据的值
     */
    private String value;

    public CacheData(long remaining, String key, String value) {
        this.remaining = System.currentTimeMillis() + remaining;
        this.key = key;
        this.value = value;
    }

    @Override
    public String toString() {
        return "CacheData{" +
                "remaining=" + remaining +
                ", key='" + key + '\'' +
                ", value='" + value + '\'' +
                '}';
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return remaining - System.currentTimeMillis();
    }

    @Override
    public int compareTo(Delayed o) {
        CacheData data = (CacheData) o;
        long diff = this.remaining - data.remaining;
        if (diff > 0) {
            return 1;
        }
        return -1;
    }

//  getter and setter

    public String getKey() {
        return key;
    }

    public String getValue() {
        return value;
    }

}

2、然后提供一个缓存的操作器。

/**
 * 操作缓存的template
 *
 * @author zhoude
 * @date 2020/6/29 21:21
 */
public class CacheTemplate extends Thread {

    /**
     * 原始数据（模拟DB）
     */
    private Map<String, CacheData> data;

    /**
     * 缓存数据
     */
    private DelayQueue<CacheData> delayQueue;

    public CacheTemplate(List<CacheData> source) {
        data = new HashMap<>(source.size());
        source.forEach(item -> data.put(item.getKey(), item));
        delayQueue = new DelayQueue<>(source);
    }

    @Override
    public void run() {
        for (; ; ) {
            try {
                // 一直从delayQueue拿数据，拿到则说明有缓存过期了
                CacheData queue = delayQueue.take();
                String key = queue.getKey();
                String value = queue.getValue();
                System.out.println(MessageFormat.format("缓存{0}已到期，value={1}", key, value));
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void put(String key, CacheData value) {
        data.put(key, value);
    }

    /**
     * 重新设置值到delayQueue中，用于模拟缓存过期后重新获取
     *
     * @param key 缓存key
     */
    public void reset(String key) {
        CacheData queue = data.get(key);
        delayQueue.add(queue);
    }

}

3、然后我们来测试下。

public class CacheTest {

    public static CacheTemplate template;

    public static void main(String[] args) throws InterruptedException {
        template = new CacheTemplate(getTemplateInitData());
        template.start();
        // 休眠7秒，用于模拟程序开始后用户的行为，改变DB中的数据
        TimeUnit.SECONDS.sleep(7L);
        template.put("cache2", new CacheData(10000L, "cache2", "value2-modify"));
        template.reset("cache2");
    }

    private static List<CacheData> getTemplateInitData() {
        List<CacheData> result = new ArrayList<>();
        result.add(new CacheData(5000L, "cache1", "value1"));
        result.add(new CacheData(10000L, "cache2", "value2"));
        result.add(new CacheData(15000L, "cache3", "value3"));
        return result;
    }

}

从结果我们可以看出来，cache2第二次的值会变成value2-modify，也就是从DB中获取的。

从demo看来，我们可以利用DelayQueue中take()方法的队列无值会一直阻塞获取的特性来达到缓存过期的目的。

总结（源码和ArrayBlockingQueue类似）

DelayQueue是阻塞队列中非常有用的一种队列，经常被用于缓存或定时任务等的设计。

以下类似的场景也可以使用：

1、异步通知的重试。

• 在很多系统中，当用户完成服务调用后， 系统有时需要将结果异步通知到用户的某个UR。由于网络等原因，很多时候会通知失败，这个时候就需要一种重试机制。

• 这时可以用DelayQueue保存通知失败的请求，失效时间可以根据已通知的次数来设定(比如: 2s、 5s、10s、 20s) ，这样每次从队列中take获取的就是剩余时间最短的请求，如果已重复通知次数超过一定阈值，则可以把消息抛弃。

• 像JUC线程池框架中的Schedu JedThreadPoolExecu tor.DelayedWorkQueu e就是一种延时阻塞队列。