Java之集合(十八)DelayQueue

　　转载请注明源出处：http://www.cnblogs.com/lighten/p/7493735.html

1.前言

　　本章介绍阻塞队列DelayQueue，这是一个无界阻塞队列。其存储延时的元素，只有延时耗尽元素才能被取出。队列头元素就是最先耗尽延时的元素，如果没有元素耗尽延时，poll操作会返回null。同样的，该队列不允许空元素。针对延时的特性，可以用户定时任务，到达时间就能取出任务执行，设计有时效的缓存，超时就清除。

2.DelayQueue

2.1 数据结构

　　该类的实现十分简单，可以说是站在其它类的肩膀上实现的。一个保证线程安全的锁，一个存储元素的优先队列，一个等待队列头元素的线程，一个触发条件。

　　优先队列之前介绍过，队列头是比较器或元素自身的比较方法比较出来的最小元素。这个队列所有的元素都必须实现Delayed接口，其方法需要给出剩余的延时时间。Delayed接口又是实现Comparable接口，注意该优先队列就是使用这个方法进行对比的，所以Comparable的实现要借助Delayed接口的方法选出剩余延时小，才能保证使用正确。

2.2 基本操作

　　放入一个Delayed元素:

　　线程安全，先加锁，然后放入一个元素到优先队列中。尝试取出，如果还是它，头元素被替换了，需要重置等待头元素的线程，唤醒阻塞的线程。

　　取出元素也先加锁，尝试取出，如果时间未到返回null，否则就取出。

　　超时的poll方法，以纳秒计算等待时间。先加锁保证线程安全，无限循环取第一个元素，如果没取到并且等待时间耗尽，直接返回null，没耗尽等待时间就继续等，直到被可用条件唤醒，或等待超时自动唤醒。如果取到了第一个元素，还需要看其剩余时间是否够了，够了就直接返回。不够等待时间又耗尽了就返回null。如果剩余等待时间比元素满足条件时间要小或者是有线程在等待第一个元素，直接等下去，等完剩余时间。否则，当前线程就是等待头元素的线程，可以等到头元素，等待头元素的时间。

　　整个类的实现并不难，leader线程感觉没什么作用，但是按照JDK的注释所说，这种领导跟随者模式可以最小化等待的时间。就是说leader线程可以等待下一个延时，其它线程需要无限等待。看代码其实也能明白，如果存在leader线程，一定是有一个线程在等待第一个元素，那么本线程就必须一直等，而拿到leader的线程，只需要等第一个元素剩余的延时就可以了。

3.使用例子

　　定义一个Delayed接口实现类：

class DelayedObject implements Delayed {
	
	private long delay;
	private long begin;
	private int value;
	
	public DelayedObject(int value, long delaySecond) {
		this.begin = System.nanoTime();
		this.delay = delaySecond;
		this.value = value;
	}

	@Override
	public int compareTo(Delayed o) {
		return getDelay(TimeUnit.NANOSECONDS) > o.getDelay(TimeUnit.NANOSECONDS) ? 1 :
			 (getDelay(TimeUnit.NANOSECONDS) == o.getDelay(TimeUnit.NANOSECONDS) ? 0 : -1);
	}

	@Override
	public long getDelay(TimeUnit unit) {
		return unit.convert(delay, TimeUnit.SECONDS) - System.nanoTime() + begin;
	}

	public int getValue() {
		return value;
	}
}

　　测试用例：

　　@Test
	public void test() {
		long begin = System.currentTimeMillis();
		DelayQueue<DelayedObject> queue = new DelayQueue<>();
		new Thread(new Runnable() {
			public void run() {
				for(int i = 0; i < 10; i++) {
					queue.offer(new DelayedObject(i, 9-i/2));
				}
			}
		}).start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					while(true) {
						DelayedObject object = queue.take();
						if(object != null) {
							System.out.println(Thread.currentThread().getName() + ":"+ object.getValue() + ",耗时："
									+ (System.currentTimeMillis()-begin)/1000);
						} else {
							break;
						}
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"poll-1").start();
		
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					while(true) {
						DelayedObject object = queue.take();
						if(object != null) {
							System.out.println(Thread.currentThread().getName() + ":"+ object.getValue() + ",耗时："
									+ (System.currentTimeMillis()-begin)/1000);
						} else {
							break;
						}
					}
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"poll-2").start();
		try {
			System.in.read();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

　　测试结果：

　　注意结果不一定和上图相同。取出顺序和System.out的顺序不一定一致，上面的结果是一个较符合顺序的结果。

 

转载于:https://www.cnblogs.com/lighten/p/7493735.html