JUC源码分析-集合篇（八）DelayQueue

JUC源码分析-集合篇（八）DelayQueue

DelayQueue 是一个支持延时获取元素的无界阻塞队列。队列使用 PriorityQueue 来实现。 队列中的元素必须实现 Delayed 接口，在创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素。

1. DelayQueue 使用场景

1.1 DelayQueue 特点

DelayQueue 也是一种比较特殊的阻塞队列，从类声明也可以看出，DelayQueue 中的所有元素必须实现 Delayed 接口。DelayQueue 队列的元素必须实现 Delayed 接口。

// 此接口的实现必须定义一个 compareTo 方法，该方法提供与此接口的 getDelay 方法一致的排序。
public interface Delayed extends Comparable<Delayed> {
    // 返回与此对象相关的剩余有效时间，以给定的时间单位表示
    long getDelay(TimeUnit unit);
}

可以看到，Delayed 接口除了自身的 getDelay 方法外，还实现了 Comparable 接口。getDelay 方法用于返回对象的剩余有效时间，实现 Comparable 接口则是为了能够比较两个对象，以便排序。

也就是说，如果一个类实现了 Delayed 接口，当创建该类的对象并添加到 DelayQueue 中后，只有当该对象的 getDalay 方法返回的剩余时间 ≤0 时才会出队。

另外，由于 DelayQueue 内部委托了 PriorityQueue 对象来实现所有方法，所以能以堆的结构维护元素顺序，这样剩余时间最小的元素就在堆顶，每次出队其实就是删除剩余时间 ≤0 的最小元素。

DelayQueue 的特点简要概括如下：

• DelayQueue 是无界阻塞队列；
• 队列中的元素必须实现 Delayed 接口，元素过期后才会从队列中取走；

1.2 DelayQueue 使用场景

DelayQueue 非常有用，可以将 DelayQueue 运用在以下应用场景。

1. 缓存系统的设计：可以用 DelayQueue 保存缓存元素的有效期，使用一个线程循环查询 DelayQueue，一旦能从 DelayQueue 中获取元素时，表示缓存有效期到了。
2. 定时任务调度：使用 DelayQueue 保存当天将会执行的任务和执行时间，一旦从 DelayQueue 中获取到任务就开始执行，比如 javax.swing.TimerQueue 就是使用 DelayQueue 实现的。ScheduledFutureTask

1.3 DelayQueue 示例

我们可以参考 ScheduledThreadPoolExecutor#ScheduledFutureTask 类的实现。

// 模仿网吧上网场景
public class DelayQueueTest extends Thread {
    DelayQueue queue =  new DelayQueue();
    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

    public static void main(String[] args) {
        DelayQueueTest wangba = new DelayQueueTest();
        wangba.start();

        wangba.shangji("A", 5);
        wangba.shangji("B", 2);
        wangba.shangji("C", 4);
    }

    public void shangji(String name, int money) {
        WangMing wm = new WangMing(name, System.currentTimeMillis() + money * 1000l);
        queue.add(wm);
        System.out.println(name + "开始上网，时间：" + format.format(new Date()) +
                "，预计下机时间为：" + format.format(new Date(wm.getEndTime())));
    }

    public void xiaji(WangMing wm) {
        System.out.println(wm.getName() + "下机，时间：" + format.format(new Date(wm.getEndTime())));
    }

    public void run() {
        while (true) {
            try {
                WangMing wm = (WangMing) queue.take();
                xiaji(wm);
            } catch (InterruptedException e) {
            }
        }
    }
}

// 网民，必须实现 Delayed 接口
class WangMing implements Delayed {
    private String name;
    private long endTime;
    private TimeUnit timeUnit = TimeUnit.SECONDS;

    @Override
    public long getDelay(TimeUnit unit) {
        return endTime - System.currentTimeMillis();
    }

    @Override
    public int compareTo(Delayed o) {
        WangMing wm = (WangMing) o;
        return this.getDelay(timeUnit) - wm.getDelay(timeUnit) > 0 ? 1 :
                (this.getDelay(timeUnit) - wm.getDelay(timeUnit) < 0 ? -1 : 0);
    }
}

程序执行结果：

A开始上网，时间：2017-12-07 09:37:52，预计下机时间为：2017-12-07 09:37:57
B开始上网，时间：2017-12-07 09:37:52，预计下机时间为：2017-12-07 09:37:54
C开始上网，时间：2017-12-07 09:37:52，预计下机时间为：2017-12-07 09:37:56
B下机，时间：2017-12-07 09:37:54
C下机，时间：2017-12-07 09:37:56
A下机，时间：2017-12-07 09:37:57

2. DelayQueue 源码分析

介绍完了 DelayQueued 的基本使用，读者应该对该阻塞队列的功能有了基本了解，接下来我们看下 Doug Lea 是如何实现 DelayQueued 的。

2.1 DelayQueue 属性

private final transient ReentrantLock lock = new ReentrantLock();
private final Condition available = lock.newCondition();

// PriorityQueue 维护队列
private final PriorityQueue<E> q = new PriorityQueue<E>();
private Thread leader = null;

上述比较特殊的是 leader 字段，我们之前已经说过，DelayQueue 每次只会出队一个过期的元素，如果队首元素没有过期，就会阻塞出队线程，让线程在 available 这个条件队列上无限等待。

为了提升性能，DelayQueue 并不会让所有出队线程都无限等待，而是用 leader 保存了第一个尝试出队的线程，该线程的等待时间是队首元素的剩余有效期。这样，一旦 leader 线程被唤醒（此时队首元素也失效了），就可以出队成功，然后唤醒一个其它在 available 条件队列上等待的线程。之后，会重复上一步，新唤醒的线程可能取代成为新的 leader 线程。这样，就避免了无效的等待，提升了性能。这其实是一种名为 Leader-Follower pattern 的多线程设计模式。

2.2 入队 offer

public boolean offer(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        q.offer(e);             // 调用 PriorityQueue#offer 方法
        if (q.peek() == e) {    // 如果入队元素在队首, 则唤醒一个出队线程
            leader = null;
            available.signal();
        }
        return true;
    } finally {
        lock.unlock();
    }
}

需要注意的是当首次入队元素时，需要唤醒一个出队线程，因为此时可能已有出队线程在空队列上等待了，如果不唤醒，会导致出队线程永远无法执行。

2.3 出队 poll

public E poll() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        E first = q.peek();
        // 1. 没有元素或元素还在有效期内则直接返回 null
        if (first == null || first.getDelay(NANOSECONDS) > 0)
            return null;
        // 2. 元素已经失效直接取出来一个
        else
            return q.poll();
    } finally {
        lock.unlock();
    }
}

不阻塞直接 poll 时很简单，再来看一下阻塞式获取元素 take 方法。

2.4 阻塞式出队 take

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        for (;;) {
            E first = q.peek();
            // 1. 集合为空时所有的线程都处于无限等待的状态。
            //    只要有元素将其中一个线程转为 leader 状态
            if (first == null)
                available.await();
            else {
                long delay = first.getDelay(NANOSECONDS);
                // 2. 元素已经过期，直接取出返回
                if (delay <= 0)
                    return q.poll();
                first = null; // don't retain ref while waiting
                // 3. 已经在其它线程设置为 leader，无限期等着
                if (leader != null)
                    available.await();
                // 4. 将 leader 设置为当前线程，阻塞当前线程（限时等待剩余有效时间）
                else {
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        available.awaitNanos(delay);
                    } finally {
                        // 4.1 尝试获取过期的元素，重新竞争
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        // 5. 队列中有元素则唤醒其它无限等待的线程
        //    leader 线程是限期等待，每次 leader 线程获取元素出队，如果队列中有元素
        //    就要唤醒一个无限等待的线程，将其设置为限期等待，也就是总有一个等待线程是 leader 状态
        if (leader == null && q.peek() != null)
            available.signal();
        lock.unlock();
    }
}

采用 take 阻塞式出队时，这里要思考下集合中元素时所有的等待线程永远进行 wait 状态不被唤醒，也就是说即使元素过期了也无法正常出队？

首先，在每次入队 offer 时，如果是第一个元素就会调用 vailable.signal() 唤醒一个等待的线程。

其次，take 方法自旋结束后如果 leader == null && q.peek() != null，需要唤醒一个等待中的出队线程。

leader == null && q.peek() != null 的含义就是——没有 leader 线程但队列中存在元素。我们之前说了，leader 线程作用之一就是用来唤醒其它无限等待的线程，所以必须要有这个判断。

当然，如果集合中没有元素了，所有的等待线程都处理无限等待的状态。

参考：

1. J.U.C之collections框架：DelayQueue

---

每天用心记录一点点。内容也许不重要，但习惯很重要！