DelayQueue

介绍

无界延迟队列，存元素的过程没有限制个数，会唤醒等待；取元素得时候，如果队列没有数据，则等待，如果队列中有数据，且队首需要等待，则进行超时等待。

使用

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * @author: Wanghui
 * @date: 2020/4/9
 * @description: 延时队列测试
 **/
public class DelayedQueueTest {
    static class Item implements Delayed {
        /* 触发时间*/
        private long time;
        String name;

        public Item(String name, long time, TimeUnit unit) {
            this.name = name;
            this.time = System.currentTimeMillis() + (time > 0 ? unit.toMillis(time) : 0);
        }

        @Override
        public long getDelay(TimeUnit unit) {
            return time - System.currentTimeMillis();//位置1
        }

        @Override
        public int compareTo(Delayed o) {
            Item item = (Item) o;
            long diff = this.time - item.time;
            if (diff <= 0) {//位置2
                return -1;
            } else {
                return 1;
            }
        }

        @Override
        public String toString() {
            return "Item{" +
                    "time=" + time +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Item item1 = new Item("item1", 5, TimeUnit.SECONDS);
        Item item2 = new Item("item2", 10, TimeUnit.SECONDS);
        Item item3 = new Item("item3", 15, TimeUnit.SECONDS);
        DelayQueue<Item> queue = new DelayQueue<>();
        queue.put(item1);
        queue.put(item2);
        queue.put(item3);
        System.out.println("begin time:" + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
        for (int i = 0; i < 3; i++) {
            Item take = queue.take();
            System.out.format("name:{%s}, time:{%s}\n", take.name, LocalDateTime.now().format(DateTimeFormatter.ISO_DATE_TIME));
        }
    }
}

打印结果：

begin time:2020-04-09T18:11:45.493
name:{item1}, time:{2020-04-09T18:11:50.271}
name:{item2}, time:{2020-04-09T18:11:55.271}
name:{item3}, time:{2020-04-09T18:12:00.271}

注意：

• 位置1，要注意返回的时间是剩余的延迟时间
• 位置2，如果改成diff >= 0
  打印结果：

begin time:2020-04-09T18:15:21.839
name:{item3}, time:{2020-04-09T18:15:36.732}
name:{item2}, time:{2020-04-09T18:15:36.742}
name:{item1}, time:{2020-04-09T18:15:36.742}

为什么会出现这样的结果？看源码可以知道每次取数据的时候会优先取队首元素，而队首元素是优先级最高的元素，Item的优先级由compareTo放决定。

源码解析

• ReentrantLock+Condition原理

一个ReentrantLock一个Condition，存取共用一个锁，Condition控制取等待，存唤醒

//存取共用锁
private final transient ReentrantLock lock = new ReentrantLock();
//取等待，存唤醒
private final Condition available = lock.newCondition();

• offer(E e)，（add，put 原理和offer一样）

将元素加入队首

	public boolean offer(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
       		//向优先级队列中添加元素
            q.offer(e);
            //如果新加入的元素排序后，位于队首，则唤醒正在等待的取操作
            if (q.peek() == e) {
                leader = null;
                available.signal();
            }
            return true;
        } finally {
            lock.unlock();
        }
    }

• take()

取出队首元素，如果没有则等待队首元素的添加唤醒；如果队首元素有延迟时间，则等待队首元素剩余延迟时间<=0时，取出

	public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
        	//死循环
            for (;;) {
            	//获取队首元素，优先级排序后的队列哦
                E first = q.peek();
                /如果没数据，则await(),等待offer唤醒
                if (first == null)
                    available.await();/则await()
                else {
                	//获取剩余的延迟时间
                    long delay = first.getDelay(NANOSECONDS);
                    //延迟时间已经达到，则返回该元素
                    if (delay <= 0)
                        return q.poll();
                    first = null;
                    //如果正在被别的线程超时等待，则当前线程等待
                    if (leader != null)
                        available.await();
                    else {
                        Thread thisThread = Thread.currentThread();
                        leader = thisThread;
                        try {
                        	//等待剩余的延迟时间，可能被超时唤醒也可能被signal唤醒
                            available.awaitNanos(delay);
                        } finally {
                            if (leader == thisThread)
                                leader = null;
                        }
                    }
                }
            }
        } finally {
            if (leader == null && q.peek() != null)
                available.signal();
            lock.unlock();
        }
    }

• poll()

队首元素不为空且剩余延迟时间<=0，则取出；否则返回null

 	public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            E first = q.peek();
            if (first == null || first.getDelay(NANOSECONDS) > 0)
                return null;
            else
                return q.poll();
        } finally {
            lock.unlock();
        }
    }

• poll(long timeout, TimeUnit unit)

在指定的时间内取数据

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
        	//死循环
            for (;;) {
            	//取队首元素
                E first = q.peek();
                if (first == null) {
                    if (nanos <= 0)
                        return null;
                    else
                        nanos = available.awaitNanos(nanos); //等待timeout时间
                } else {
                	//获取剩余延迟时间
                    long delay = first.getDelay(NANOSECONDS);
                    if (delay <= 0)
                        return q.poll();
                    if (nanos <= 0)
                        return null;
                    first = null; // don't retain ref while waiting
                    if (nanos < delay || leader != null)
                        nanos = available.awaitNanos(nanos);
                    else {
                        Thread thisThread = Thread.currentThread();
                        leader = thisThread;
                        try {
                            long timeLeft = available.awaitNanos(delay);
                            nanos -= delay - timeLeft;
                        } finally {
                            if (leader == thisThread)
                                leader = null;
                        }
                    }
                }
            }
        } finally {
            if (leader == null && q.peek() != null)
                available.signal();
            lock.unlock();
        }
    }