DelayQueue：实现原理、主要方法和使用示例

DelayQueue：实现原理、主要方法和使用示例

---

  DelayQueue是JDK原生支持的数据结构，能非常方便地支持单机和数据规模不大的延迟队列的场景。DelayQueue通过维护一个PriorityQueue优先队列数据结构来实现延迟队列，之所以要使用优先队列来实现，主要有以下两点原因：

1. 如果使用一般的链表或者数组来进行有序的存储任务，排序都需要O(n*logn)的时间复杂度；
2. 延迟队列并不需要维护一个完全有序的队列，仅需找到当前最接近执行时间的任务即可；

  综上两点采用基于二叉堆实现的PriorityQueue来作为底层数据结构是最高效。

public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
    implements BlockingQueue<E> {}

  根据DelayQueue类定义来看，在使用DelayQueue之前需要有一个实现自Delayed接口的泛型类，Delayed接口继承了Comparable接口，所以泛型类需要实现compareTo和getDelay两个方法。

构造方法

public DelayQueue() {}

public DelayQueue(Collection<? extends E> c) {
    this.addAll(c);
}

  DelayQueue提供两个构造方法，一个是默认无参的构造方法；另一个则是初始化延迟队列的构造方法，且默认初始化任务中的参数必须要都是实现自Delayed接口的泛型类。

主要方法

  DelayQueue提供了不少API，但是offer和take这两个接口尤其重要，一个用于插入一个带执行时间的任务，一个则是从当前延迟队列中选择一个到期的任务，如果队列头的任务没有到期则会阻塞当前线程，直到满足执行条件唤醒当前线程执行任务。

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();
    }
}

  
  offer主要用于插入一个带执行时间的任务，其逻辑如下：
  1. 在真正执行插入逻辑之前会先上一把可重入锁，确保线程安全，最后在执行完插入逻辑之后释放当前锁；
  2. 将当前任务放入优先队列中，确保堆顶元素是最小的，即小顶堆；
  3. 判断当前优先队列中堆顶的任务是否与当前插入任务相等，如果相等，就将leader设置为null并将Condition信号量设置为signal唤醒一个消费者。

take方法

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        for (;;) {
            E first = q.peek();
            if (first == null)
                available.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 {
                        available.awaitNanos(delay);
                    } finally {
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        if (leader == null && q.peek() != null)
            available.signal();
        lock.unlock();
    }
}

  
  take主要从当前延迟队列中获取一个当前的任务，其逻辑如下：
  1. 首先还是在真正逻辑的前后加一把可重入锁和执行完逻辑后释放锁；
  2. take方法中使用一个for (;;)无限循环来获取到期的任务，如果当前没有到期的任务则一直自旋阻塞，直到有满足执行条件的任务为止；
  3. 从优先队列中获取最小堆堆顶元素（peek方法不会删除元素），如果当前堆顶元素为空，就会进入阻塞状态；
  4. 如果当前堆顶元素不为空，就会判断当前任务是否达到了执行时间，达到执行时间直接返回任务，反之阻塞当前线程，直到堆顶元素到期；
  5. 如果leader不为空，表明已经有其他线程正在等待这个堆顶元素；
  6. 如果leader为空，就将leader设置为当前线程，并将Condition信号量设置为delay纳秒阻塞时间；
  7. leader线程被唤醒并获取到锁之后会将leader设置为空。

Leader/Followers模式

  为了提高效率，DelayQueue底层采用了Leader/Followers的线程模型，是一种常见的多线程同步模式，用于解决生产者-消费者问题。换言之Leader/Followers就是永远只有一个leader线程处于可消费状态，而其它的follower线程就只有在成为leader才能切换为可消费状态。从上述的offer和take方法来看，每当当前任务不处于执行时间，就会将当前线程设置为leader便于阻塞持续监听，同时也防止其它线程参与不良的竞争。只要堆顶任务已经执行完毕，就会将当前与leader绑定的线程清空，然后开启下一轮leader选举。
  Leader/Followers的线程模型一共有Follower、Candidate和Leader三个状态，其详细介绍如下：

• Follower状态：
  1. 线程处于等待状态，等待被唤醒或被选为候选者。
  2. 当Leader线程释放领导权时，Follower线程有机会被选为新的候选者。
• Candidate状态：
  1. 线程尝试获取领导权，可能会成功也可能失败。
  2. 如果成功，线程将成为新的Leader。
  3. 如果失败，线程将回到Follower状态。
• Leader状态：
  1. 线程拥有领导权，可以执行特定的任务，例如在DelayQueue中取出到期的元素。
  2. Leader线程在完成任务或等待超时后，将释放领导权，并回到Follower状态。

示例代码

  正如上述所讲，自定义延迟元素类都必须实现Delayed接口，然后实现该接口下的getDelay和compareTo方法，如下代码所示：

public class DelayedTask implements Delayed {

    /**
     * 延迟时间（毫秒）
     */
    private final long delayTime;

    /**
     * 过期时间（纳秒）
     */
    private final long expire;

    public DelayedTask(long delayTime) {
        this.delayTime = delayTime;
        this.expire = System.nanoTime() + TimeUnit.NANOSECONDS.convert(delayTime, TimeUnit.MILLISECONDS);
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(expire - System.nanoTime(), TimeUnit.NANOSECONDS);
    }

    @Override
    public int compareTo(Delayed other) {
        if (this == other) {
            return 0;
        }
        DelayedTask x = (DelayedTask) other;
        long diff = this.expire - x.expire;
        return (diff == 0) ? 0 : ((diff < 0) ? -1 : 1);
    }

    /**
     * 用于任务执行的方法
     */
    public void execute() {
        // 逻辑代码
    }
}

  DelayedTask放入DelayQueue队列，生产、消费和执行。

public void doExecute() {
    DelayQueue<DelayedTask> queue = new DelayQueue<>();

    // 添加延迟任务到队列
    // 1秒后执行
    queue.put(new DelayedTask(1000));
    // 3秒后执行
    queue.put(new DelayedTask(3000));
    // 5秒后执行
    queue.put(new DelayedTask(5000));

    while (true) {
        DelayedTask task = queue.take();
        task.execute();
    }
    
}

---

一键三连，让我的信心像气球一样膨胀！