Java DelayQueue实现任务延时示例讲解

让我详细讲解一下“Java DelayQueue实现任务延时示例讲解”的完整攻略。

什么是DelayQueue

DelayQueue 是一个基于优先级队列 PriorityQueue 实现的无界阻塞队列，用于放置在给定延迟时间后才能被消费的元素（任务）。DelayQueue 中的元素必须实现 java.util.concurrent.Delayed 接口，该接口只有两个方法：

public interface Delayed extends Comparable<Delayed> {
    long getDelay(TimeUnit unit); // 返回元素的剩余延迟时间，该延迟时间需要用到给定的时间单位
    int compareTo(Delayed o); // 比较元素的延迟时间大小，实现该方法是为了能够按延迟时间进行排序
}

在 DelayQueue 中，只有延迟时间小于等于 0 的元素才可以被取出。

DelayQueue实现任务延时的示例

下面，我们来看两个示例，演示如何使用 DelayQueue 实现任务延时。

示例一：丢到 DelayQueue 里

我们可以将带有延时的任务包装成实现了 Delayed 接口的类，并将任务加入到 DelayQueue 中。当执行任务的线程要取出元素时，如果元素的延迟时间已经过期，那么任务就会被执行。

示例代码：

public class DelayedTask implements Delayed {

    private long delayTime; // 延迟时间，单位是秒
    private String taskName; // 任务名
    private long expire; // 到期时间，单位是秒

    // 构造方法，传入任务名和延迟时间
    public DelayedTask(String taskName, long delayTime) {
        this.taskName = taskName;
        this.delayTime = delayTime;

        // 计算到期时间
        this.expire = System.currentTimeMillis() + delayTime * 1000;
    }

    // 获取剩余延迟时间
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(expire - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    // 比较延迟时间大小，实现该方法是为了能够按延迟时间进行排序
    @Override
    public int compareTo(Delayed o) {
        return (int) (this.delayTime - ((DelayedTask) o).delayTime);
    }

    // 执行任务
    public void run() {
        System.out.println(taskName + " is running");
    }
}

使用 DelayedTask 类创建任务并加入 DelayQueue：

public class DelayedTaskDemo {

    public static void main(String[] args) throws InterruptedException {
        DelayQueue<DelayedTask> delayQueue = new DelayQueue<>();

        // 创建3个任务，分别延迟1秒、2秒和3秒
        DelayedTask task1 = new DelayedTask("Task-1", 1);
        DelayedTask task2 = new DelayedTask("Task-2", 2);
        DelayedTask task3 = new DelayedTask("Task-3", 3);

        // 将任务加入 DelayQueue
        delayQueue.put(task1);
        delayQueue.put(task2);
        delayQueue.put(task3);

        System.out.println("Tasks added to DelayQueue");

        // 线程执行任务
        while (true) {
            DelayedTask task = delayQueue.take();

            if (task != null) {
                task.run();
            }
        }
    }
}

示例二：使用 ScheduledExecutorService

另一种实现任务延时的方式是使用 ScheduledExecutorService。下面的示例就演示了如何使用 ScheduledExecutorService 实现任务延时。

示例代码：

public class ScheduledExecutorServiceDemo {

    public static void main(String[] args) throws InterruptedException {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);

        // 延迟2秒执行
        executorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("Task-1 is running...");
            }
        }, 2, TimeUnit.SECONDS);

        // 延迟3秒执行，每隔5秒重复执行
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("Task-2 is running...");
            }
        }, 3, 5, TimeUnit.SECONDS);

        // 关闭线程池
        executorService.shutdown();
    }
}

第一个任务会延迟2秒后执行，第二个任务会延迟3秒后运行，并且每隔5秒重复执行一次。

总结

以上就是使用 DelayQueue 实现任务延时的完整攻略，其中包括了两个示例。DelayQueue 可以用于需要在一定时间之后才能处理的任务，而 ScheduledExecutorService 则更适合于需要定时执行或重复执行的任务。