使用DelayQueue模拟一个缓存工具类

关于集合类，我们平时用的较多的有ArrayList，HashMap，TreeSet等，java集合框架还提供了一个常用接口Queue，在java.util.concurrent包下有大量队列的实现类，可见队列在并发编程里广泛使用，大致类图如下：

java.util.concurrent包下提供了很多实用的类，DelayQueue便是其中之一，它是一种延迟队列，主要用于缓存和任务处理等。下面是一个使用DelayQueue实现一个简单的缓存工具的模拟代码，用于练习使用DelayQueue类：

package com.jack.jucstudy.delayQueue;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.DelayQueue;
public class MyCacheUtil {
	private final DelayQueue cacheQueue = new DelayQueue();
	public MyCacheUtil() {
		run();
	}
	/**
	 * 设置不过期的缓存
	 * @param key
	 * @param value
	 */
	public void set(String key, Object value) {
		Map data = new HashMap();
		data.put(key, value);
		cacheQueue.add(CacheObject.buildPermanentObject(data));
	}
	/**
	 * 设置带有过期时间的缓存
	 * @param key
	 * @param value
	 * @param time
	 */
	public void set(String key, Object value, long time) {
		Map data = new HashMap();
		data.put(key, value);
		cacheQueue.add(CacheObject.buildTemporaryObject(data, time));
	}
	/**
	 * 获取缓存
	 * @param key
	 * @return null if the value is not exists
	 * @exception NullPointerException: if key is null
	 */
	public Object get(String key) {
		if(key == null) {
			throw new NullPointerException();
		}
		Iterator iterator = cacheQueue.iterator();
		while(iterator.hasNext()) {
			CacheObject data = iterator.next();
			Map dataMap = data.getData();
			if(dataMap.containsKey(key)) {
				return dataMap.get(key);
			}
		}
		return null;
	}
	/**
	 * 开启一个线程，一直不停地循环跑，一遇到过期的，就从队列中取出来删掉
	 */
	private void run() {
		new Thread(new Runnable() {
			@Override
			public void run() {
				while(true) {
					try {
						CacheObject take = cacheQueue.take();
						System.out.println("缓存" + take + "已失效，从缓存队列中删除");
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}).start();
	}
}

代码片断一：MyCacheUtil.java类，模拟了一个缓存工具类。可以存储key，value的键值对，也可以设置过期时间，以秒为单位，过期之后自动从缓存队列中删除。

package com.jack.jucstudy.delayQueue;

import java.util.Map;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class CacheObject implements Delayed {
	private Map data;
	/**
	 * 缓存存在的时间，以秒为单位
	 */
	private Long timeDelay;
	/**
	 * 是否为永不失效缓存
	 */
	private Boolean isPermanent;
	/**
	 * 创建对象时的时间戳
	 */
	private Long currentTimeStampt;
	private CacheObject(Map data, Long timeDelay, Boolean isPermanent) {
		super();
		this.setData(data);
		this.timeDelay = timeDelay;
		this.isPermanent = isPermanent;
		this.currentTimeStampt = System.currentTimeMillis();
	}
	public static CacheObject buildPermanentObject(Map data) {
		return new CacheObject(data, 0l, true);
	}
	public static CacheObject buildTemporaryObject(Map data, Long delayTime) {
		return new CacheObject(data, delayTime, false);
	}
	@Override
	public int compareTo(Delayed o) {
		CacheObject delay = (CacheObject)o;
		//永不过期
		if(isPermanent) {
			return 1;
		}else if(delay.isPermanent) {
			return -1;
		}
		return this.getDelay(TimeUnit.NANOSECONDS) - delay.getDelay(TimeUnit.NANOSECONDS) > 0 ? 1:-1;
	}

	/**
	 * 返回的值小于或等于0时发生到期
	 */
	@Override
	public long getDelay(TimeUnit unit) {
		//永不过期
		if(isPermanent)
			return 1 * 1000;
		return currentTimeStampt + timeDelay * 1000 - System.currentTimeMillis();
	}
	public Map getData() {
		return data;
	}
	public void setData(Map data) {
		this.data = data;
	}
	@Override
	public String toString() {
		return "CacheObject [data = "+data.toString()+"],过期时间为[delayTime = "+timeDelay+"秒]";
	}
}

代码片段二：CacheObject.java类，封装了缓存数据，实现Delayed接口，使这个类在DelayQueue中到过期时间自动上升到队列头

package com.jack.jucstudy.delayQueue;

public class Main {

	public static void main(String[] args) {
		MyCacheUtil cacheUtil = new MyCacheUtil();
		cacheUtil.set("1", "abc");
		cacheUtil.set("2", "bcd", 5);
		cacheUtil.set("3", "cde", 10);
		try {
			Thread.sleep(5 * 1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("暂停5秒之后获取缓存1" + cacheUtil.get("1"));
		System.out.println("暂停5秒之后获取缓存2" + cacheUtil.get("2"));
		System.out.println("暂停5秒之后获取缓存3" + cacheUtil.get("3"));
		try {
			Thread.sleep(5 * 1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("暂停10秒之后获取缓存1" + cacheUtil.get("1"));
		System.out.println("暂停10秒之后获取缓存2" + cacheUtil.get("2"));
		System.out.println("暂停10秒之后获取缓存3" + cacheUtil.get("3"));
		try {
			Thread.sleep(5 * 1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("暂停15秒之后获取缓存1" + cacheUtil.get("1"));
		System.out.println("暂停15秒之后获取缓存2" + cacheUtil.get("2"));
		System.out.println("暂停15秒之后获取缓存3" + cacheUtil.get("3"));
	}
}

代码片段三：测试类

---

关键点在CacheObject实现的getDelay()方法和CompareTo()方法上。一定要特别注意。

jdk文档对DelayQueue的解释：

Delayed 元素的一个无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部 是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队列没有头部，并且 poll 将返回 null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于等于 0 的值时，将发生到期。即使无法使用 take 或 poll 移除未到期的元素，也不会将这些元素作为正常元素对待。例如，size 方法同时返回到期和未到期元素的计数。此队列不允许使用 null 元素。