Java延迟队列DelayQueue原理详解

//可重入同步锁
private final transient ReentrantLock lock = new ReentrantLock();
//DelayQueue的实现依赖于PriorityQueue(优先队列)
private final PriorityQueue<E> q = new PriorityQueue<E>();
//第一个等待某个延时对象的线程，在延时对象还没有到期时其他线程看到这个leader不为null，那么就直接wait
//主要是为了避免大量线程在同一时间点唤醒，导致大量的竞争，反而影响性能
private Thread leader = null;
//条件队列，用于wait线程
private final Condition available = lock.newCondition();

    //从上面属性就可以看出，DelayQueue采用了饿汉模式，调用构造方法即创建了队列实例
    public DelayQueue() {}
    /**
     * 创建一个DelayQueue，最初包含给定的Collection实例集合。
     * @param c 最初包含的元素集合
     */
    public DelayQueue(Collection<? extends E> c) {
        this.addAll(c);
    }

public boolean offer(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        //调用优先队列
        q.offer(e);
        //检验元素是否为队首，是则设置 leader 为null, 并唤醒一个消费线程  
        if (q.peek() == e) {
            leader = null;
            available.signal();
        }
        return true;
    } finally {
        lock.unlock();
    }
}

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        for (;;) {
            //从优先队列中获取第一个元素，peek方法不会删除元素
            E first = q.peek();
            //如果获取不到数据，则调用available.await()进入阻塞状态
            if (first == null)
                available.await();
            else {
                //获取当前延时对象是否到期
                long delay = first.getDelay(NANOSECONDS);
                //到期那么返回这个延时对象
                if (delay <= 0)
                    return q.poll();
                first = null; // 
                //leader不为空，表明已经有其他线程在等待这个延时对象了
                //为什么不available.awaitNanos(delay)呢？这将会导致大量的线程在同一时间点被唤醒，然后去竞争
                //这个到期的延时任务，影响性能，还不如直接将他们无时间限制的wait，leader线程或者其他新进来的线程获取到延时对象后，去唤醒
                //让他们去竞争下一个延时对象
                if (leader != null)
                    available.await();
                else {
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        //指定纳秒级别线程阻塞时间，当前wait住的线程被唤醒后有可能与其他线程竞争失败，就会进入了同步队列阻塞，那个抢到锁的线程就会取走这个延时对象
                        available.awaitNanos(delay);
                    } finally {
                        //leader线程被唤醒并获取到锁之后会将leader设置为空
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        //leader为空并且队列不为空，那么唤醒正在等待的线程
        if (leader == null && q.peek() != null)
            available.signal();
        lock.unlock();  //释放锁
    }
}

public boolean remove(Object o) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        return q.remove(o);
    } finally {
        lock.unlock();
    }
}

public interface Delayed extends Comparable<Delayed> {
    /**
     * 返回与此对象关联的剩余延迟（给定的时间单位）。
     * @param unit 时间单位
     * @返回剩余延迟；零值或负值表示 延迟已过期
     */
    long getDelay(TimeUnit unit);
}

class MyDelay implements Delayed {
    long delayTime; // 延迟时间
    long expire; // 过期时间
    public MyDelay(long delayTime, Thread t) {
        this.delayTime = delayTime;
        // 过期时间 = 当前时间 + 延迟时间
        this.expire = System.currentTimeMillis() + delayTime;
    }
    /**
     * 剩余时间 = 到期时间 - 当前时间
     */
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(this.expire - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }
    /**
     * 优先级规则：两个任务比较，时间短的优先执行
     */
    @Override
    public int compareTo(Delayed o) {
        long f = this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS);
        return (int) f;
    }
}

class MyDelay<T> implements Delayed {
    long delayTime; // 延迟时间
    long expire; // 过期时间
    T data;
    public MyDelay(long delayTime, T t) {
        this.delayTime = delayTime;
        // 过期时间 = 当前时间 + 延迟时间
        this.expire = System.currentTimeMillis() + delayTime;
        data = t;
    }
    /**
     * 剩余时间 = 到期时间 - 当前时间
     */
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(this.expire - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }
    /**
     * 优先级规则：两个任务比较，时间短的优先执行
     */
    @Override
    public int compareTo(Delayed o) {
        long f = this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS);
        return (int) f;
    }
    @Override
    public String toString() {
        return "delayTime=" + delayTime +
                ", expire=" + expire +
                ", data=" + data;
    }
}

public class DelayQueueDemo {
    static BlockingQueue<Delayed> queue = new DelayQueue();
    public static void main(String[] args) throws InterruptedException {
        queue.add(new MyDelay(8, "第一次添加任务"));
        queue.add(new MyDelay(3, "第二次添加任务"));
        queue.add(new MyDelay(5, "第三次添加任务"));
        while (!queue.isEmpty()) {
            Delayed delayed = queue.take();
            System.out.println(delayed);
        }
    }
}