Java中的 DelayQueue drainTo() 方法及示例

DelayQueue 是 Java 中的一个延迟队列实现，它提供了一个基于时间的优先级队列。其存储元素必须是实现了 Delayed 接口的对象，即需要在一定时间后才可获取。drainTo() 方法是 java.util.concurrent.BlockingQueue 接口中的一种方法，DelayQueue 实现了该接口，因此也可以使用该方法。

drainTo(int maxElements)

该方法将此队列中的一些或全部元素转移到给定集合中，最多可以移动指定数量的元素（maxElements）。如果队列没有要立即可用于接受的元素，则此方法的操作被阻塞，等待至少一个元素可用，但抛出 InterruptedException 以响应中断而停止等待。如果队列已关闭，则抛出 IllegalStateException。否则，此方法将删除已从队列中移动的所有元素。

示例

下面是一个简单的示例代码，其中我们创建了5个任务，它们将在一定延迟后被执行，然后我们将调用 drainTo() 方法将所有任务转移到一个新的集合中。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

class Task implements Delayed {
    private String name;
    private long duration;

    public Task(String name, long duration) {
        this.name = name;
        this.duration = TimeUnit.MILLISECONDS.convert(duration, TimeUnit.SECONDS) + System.currentTimeMillis();
    }

    public String getName() {
        return name;
    }

    public long getDuration() {
        return duration;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(duration - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        return Long.compare(duration, ((Task) o).getDuration());
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        DelayQueue<Task> delayQueue = new DelayQueue<>();
        List<Task> result = new ArrayList<>();

        Task task1 = new Task("Task 1", 5);
        Task task2 = new Task("Task 2", 3);
        Task task3 = new Task("Task 3", 8);
        Task task4 = new Task("Task 4", 2);
        Task task5 = new Task("Task 5", 4);

        delayQueue.add(task1);
        delayQueue.add(task2);
        delayQueue.add(task3);
        delayQueue.add(task4);
        delayQueue.add(task5);

        System.out.println("DelayQueue before drainTo():");
        for (Task task : delayQueue) {
            System.out.println(task.getName() + " -> " + task.getDuration());
        }

        delayQueue.drainTo(result);

        System.out.println("DelayQueue after drainTo():");
        for (Task task : delayQueue) {
            System.out.println(task.getName() + " -> " + task.getDuration());
        }

        System.out.println("Resulting List after drainTo()");
        for (Task task : result) {
            System.out.println(task.getName() + " -> " + task.getDuration());
        }
    }
}

程序的输出结果如下：

DelayQueue before drainTo():
Task 4 -> 1617096795933
Task 2 -> 1617096796933
Task 5 -> 1617096797367
Task 1 -> 1617096798373
Task 3 -> 1617096801955
DelayQueue after drainTo():
Task 3 -> 1617096801955
Resulting List after drainTo():
Task 4 -> 1617096795933
Task 2 -> 1617096796933
Task 5 -> 1617096797367
Task 1 -> 1617096798373

我们可以看出，在调用 drainTo() 方法后，队列中的所有任务都被转移到了 result 集合中。