JAVA面试-延迟队列的实现方式

已于 2025-03-04 22:12:57 修改
阅读量1.3k 收藏 16
点赞数 30
文章标签： java 开发语言 redis rabbitmq
于 2025-03-04 21:54:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_48625029/article/details/146026655
版权

1. 使用java.util.concurrent.DelayQueue

1.1定义

  •  DelayQueue是JDK提供的一个无界阻塞队列，内部基于优先队列实现。队列中的元素必须实现Delayed接口，通过getDelay()方法计算延迟时间。
  • DelayQueue 是线程安全的，它通过内置的锁机制（ReentrantLock）来保证多线程环境下的操作安全。主要的线程安全操作包括：

    • 入队操作（put() 或 offer()）：在添加新任务时，DelayQueue 会获取锁，将任务插入优先队列，并根据延迟时间调整堆结构。

    • 出队操作（take() 或 poll()）：在获取任务时，DelayQueue 会检查堆顶任务是否到期。如果未到期，线程会进入等待状态，直到任务到期或被中断。

    • 条件变量：DelayQueue 使用 Condition 来管理等待线程。当任务到期时，会唤醒等待的线程，使其能够继续执行。

1.2原理

源码如下

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

    /**
     * 排它锁，用于保证线程安全
     */
    private final transient ReentrantLock lock = new ReentrantLock();

    /**
     * 底层是基于PriorityQueue实现
     */
    private final PriorityQueue<E> q = new PriorityQueue<E>();

    /**
     * 当前线程
     */
    private Thread leader = null;

    /**
     * 条件队列
     */
    private final Condition available = lock.newCondition();

}

DelayQueue 的底层是基于 PriorityQueue 实现的。PriorityQueue 是一个无界优先队列，它基于堆结构（最小堆）来维护元素的顺序。在 DelayQueue 中，队列会根据元素的延迟时间（getDelay() 方法返回的值）对元素进行排序，延迟时间越短的元素越先出队。

  • 最小堆特性：优先队列的堆顶元素总是延迟时间最短的任务，即 getDelay() 返回值最小的元素。

  • 动态调整：当任务的延迟时间到期后，队列会自动调整堆结构，确保下一个到期的任务位于堆顶。

1.3 例子

        在这个例子中，DelayedTask实现了Delayed接口，DelayQueue会根据getDelay()方法的返回值对任务进行排序，并在延迟时间到期后返回。

为了使对象能够被 DelayQueue 管理，必须实现 Delayed 接口，该接口包含两个方法：

  • long getDelay(TimeUnit unit)：返回当前时间与任务到期时间之间的剩余延迟时间（以指定的时间单位表示）。如果任务已经到期，则返回非正数（<= 0）。

  • int compareTo(Delayed other)：用于比较两个延迟任务的优先级。通常基于延迟时间进行比较，延迟时间越短的任务优先级越高。

import java.util.concurrent.*;

class DelayedTask implements Delayed {
    private final long triggerTime;
    private final String name;

    public DelayedTask(String name, long delayTime, TimeUnit unit) {
        this.name = name;
        this.triggerTime = System.currentTimeMillis() + unit.toMillis(delayTime);
    }

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

    @Override
    public int compareTo(Delayed o) {
        return Long.compare(this.triggerTime, o.getDelay(TimeUnit.MILLISECONDS));
    }

    @Override
    public String toString() {
        return "Task{" + name + "}";
    }
}

public class DelayQueueExample {
    public static void main(String[] args) throws InterruptedException {
        DelayQueue<DelayedTask> queue = new DelayQueue<>();
        queue.put(new DelayedTask("Task1", 2, TimeUnit.SECONDS));
        queue.put(new DelayedTask("Task2", 1, TimeUnit.SECONDS));

        while (!queue.isEmpty()) {
            DelayedTask task = queue.take();
            System.out.println("Executing: " + task);
        }
    }
}

2、使用Redis的ZSET

2.1定义

Redis的有序集合（ZSET）可以通过score属性实现延迟队列。将元素的score设置为过期时间戳，消费端轮询集合，比较score与当前时间戳，从而实现延迟队列。

2.2原理

Redis 的有序集合（ZSET）是一种基于分数（score）对元素进行排序的数据结构。每个元素都有一个唯一的分数，元素会根据分数从小到大自动排序。这一特性使得 ZSET 非常适合用于实现延迟队列，因为可以将任务的执行时间戳作为分数，从而按时间顺序排列任务。

（1）任务入队

当任务被添加到延迟队列时，会计算任务的执行时间戳（通常是当前时间戳加上延迟时间），并将任务内容和执行时间戳存入 ZSET。

  • 计算执行时间戳：execute_time = current_timestamp + delay。

  • 将任务存入 ZSET：使用 ZADD 命令将任务的执行时间戳作为分数，任务内容作为值存入 ZSET。

（2）任务出队

消费者会定期检查 ZSET 中分数小于等于当前时间戳的任务（即已经到期的任务），并执行这些任务。

  • 获取到期任务：使用 ZRANGEBYSCORE 命令获取分数小于等于当前时间戳的任务。

  • 执行任务：对每个到期任务执行相应的逻辑。

  • 删除任务：任务执行完成后，使用 ZREM 命令从 ZSET 中删除该任务。

（3）定期检查

为了持续处理到期任务，消费者通常会启动一个定时任务，每隔一定时间（例如每秒）检查一次 ZSET。

  • 轮询机制：消费者会不断循环，定期调用 ZRANGEBYSCORE 获取到期任务并处理。

  • 优化：为了避免频繁轮询，可以结合 Redis 的发布/订阅机制或 Lua 脚本，减少不必要的检查

2.3例子

用Jedis实现

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;

public class RedisDelayQueue {
    private static final String DELAY_QUEUE = "delayQueue";

    public static void main(String[] args) throws InterruptedException {
        Jedis jedis = new Jedis("localhost", 6379);
        jedis.del(DELAY_QUEUE); // 清空队列

        // 添加延迟任务
        jedis.zadd(DELAY_QUEUE, System.currentTimeMillis() + 5000, "Task1");
        jedis.zadd(DELAY_QUEUE, System.currentTimeMillis() + 10000, "Task2");

        // 消费端轮询
        while (true) {
            Tuple task = jedis.zrangeWithScores(DELAY_QUEUE, 0, 0).iterator().next();
            long score = (long) task.getScore();
            if (score <= System.currentTimeMillis()) {
                System.out.println("Executing: " + task.getElement());
                jedis.zrem(DELAY_QUEUE, task.getElement());
            }
            Thread.sleep(1000);
        }
    }
}

用redission实现

//生产者
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class DelayQueueProducer {
    @Autowired
    private RedissonClient redissonClient;

    public void addTask(String task, long delay) {
        RDelayedQueue<String> delayedQueue = redissonClient.getDelayedQueue("my_delayed_queue");
        delayedQueue.offer(task, delay, TimeUnit.SECONDS);
        System.out.println("Task added: " + task + ", with delay: " + delay + " seconds");
    }
}
//消费者
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

@Service
public class DelayQueueConsumer {
    @Autowired
    private RedissonClient redissonClient;

    @Scheduled(fixedDelay = 1000) // 每秒检查一次
    public void processQueue() {
        RDelayedQueue<String> delayedQueue = redissonClient.getDelayedQueue("my_delayed_queue");
        String task = delayedQueue.poll(); // 获取到期任务
        if (task != null) {
            System.out.println("Processing task: " + task);
        }
    }
}

3、使用RabbitMQ的延时队列

3.1定义

RabbitMQ通过消息的TTL（Time To Live）和死信交换机（DLX）实现延时队列。

3.2原理

  • 消息 TTL：为队列中的消息设置一个过期时间（TTL），当消息的 TTL 到期后，消息会被丢弃。

  • 死信交换机（DLX）：当消息因为 TTL 到期而被丢弃时，RabbitMQ 会将这些消息转发到一个指定的死信交换机（DLX）。DLX 再将消息路由到另一个队列，供消费者消费。

3.3例子

生产者

// 生产者
Channel channel = connection.createChannel();
channel.queueDeclare("delayQueue", true, false, false, null);
AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
        .deliveryMode(2)
        .expiration("5000") // 设置消息TTL为5秒
        .build();
channel.basicPublish("", "delayQueue", properties, "Hello, Delayed Message!".getBytes());

消费者

// 消费者
Channel channel = connection.createChannel();
channel.queueDeclare("delayQueue", true, false, false, null);
channel.basicConsume("delayQueue", true, (consumerTag, message) -> {
    System.out.println("Received: " + new String(message.getBody()));
}, consumerTag -> {});

cccc来财
关注
一口气说出Java 6种延时队列的实现方法(面试官也得服)
08-19
主要介绍了一口气说出Java 6种延时队列的实现方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
JAVA 实现延迟队列的方法
08-18
主要介绍了JAVA 实现延迟队列的方法，文中讲解非常详细，供大家参考和学习，感兴趣的朋友可以了解下
如何实现延迟任务，这11种方式才算优雅！
最新发布
z1ztai的博客
04-25 684
延迟任务在我们日常生活中比较常见，比如订单支付超时取消订单功能，又比如自动确定收货的功能等等。所以本篇文章就来从实现到原理来盘点延迟任务的11种实现方式，这些方式并没有绝对的好坏之分，只是适用场景的不大相同。
一口气说出 6种 延时队列的实现方法，面试官也得服
程序员内点事
05-07 2493
JDK的DelayQueue JDK ScheduledExecutorService 定时器轮询遍历数据库记录 利用quartz等定时任务 netty时间轮 Ｑuartz 定时任务 Redis 实现 RabbitMQ 实现延时队列 https://www.jianshu.com/p/a8c1458998aa ...
JAVA实现延时队列
薄红的博客
06-07 1306
JAVA实现延时队列
Java实现一个延时队列
FBB360JAVA的博客
11-06 1555
业务中经常会出现各种涉及到定时，延迟执行的需求任务。有一种队列专门处理这种情况。那就是延时队列。
java中延时队列的实现
qq_43649799的博客
03-04 2861
我是一名CRUD工程师，最近我朋友突然来问我如何实现延时队列，我脱口而出就是MQ。不过突然想到公司的项目好像用的是java的一个原生类。于是我就想着趁周末的时间好好的去探究一下各方法实现延时队列的优缺点
Java面试要点112 - Java延迟队列DelayQueue技术解析
程序媛学姐的博客
01-01 627
DelayQueue通过结合优先级队列和延迟特性，为Java并发编程提供了一个强大的工具。它的实现机制保证了线程安全性和元素的有序处理，使其特别适合于需要延迟处理的场景。在实际应用中，开发者应注意正确实现Delayed接口，合理设置延迟时间，并妥善处理线程安全和中断问题。
Java实现Redis延时队列
21届Java攻城狮&Python民兵
02-19 1898
“如何实现Redis延时队列”这个面试题应该也是比较常见的，解答如下：使用sortedset（有序集合） ，拿时间戳作为 score ，消息内容作为key 调用 zadd 来生产消息，消费者用zrangebyscore 指令获取 N 秒之前的数据轮询进行处理。
2024年java面试题-SpringCloud面试题
04-22
### 2024年Java面试题之Spring Cloud面试题详解 #### 一、什么是微服务架构？ 微服务架构是一种设计方法论，旨在将大型单体应用分解为一系列小型、可独立部署的服务单元（即微服务）。每个微服务专注于执行单一...
2024年java面试题-Kafka面试题
04-22
### Apache Kafka核心知识点详解 #### 一、Apache Kafka概述 **Apache Kafka** 是一款开源的...掌握Kafka的核心概念和工作原理对于Java开发人员来说至关重要，特别是在涉及大规模数据处理和实时分析的应用场景中。
Java 实现延迟队列
keyboard专栏
09-24 463
1、 创建延时消息的实体类 import java.util.concurrent.Delayed; import java.util.concurrent.TimeUnit; /** * 延时消息实体类 * @program: ReservedInstance * @description: DelayMessage * @author: sunyuhua * @create: 2021-09-18 11:53 **/ public class DelayMessage implemen
java实现延时队列
占啟的博客
05-14 3168
延时队列主要应用场景是用户登录后延时推送消息，通知等，一般用mq中间件来弄，下面我来用java实现 一、消息实体类实现Delayed接口 import lombok.Data; import java.util.concurrent.Delayed; import java.util.concurrent.TimeUnit; /** * 消息实体类实现Delayed接口 * @author zhanqi * @since 2021/5/13 13:46 */ @Data public .
Java中延迟队列使用指南
盲目的拾荒者的博客
09-24 1251
1.介绍 本文中，将了解 java.util.concurrent 包中的 DelayQueue 构造。 这是一个阻塞队列，可以在生产者-消费者程序中使用。 它有一个非常有用的特性——当消费者想要从队列中取出一个元素时，只能在该特定元素的延迟到期时才能取出。 2.为DelayQueue中的元素实现Delayed 想要放入 DelayQueue 的每个元素都需要实现 Delayed 接口。 假设要创建一个 DelayObject 类。 该类的实例将被放入 DelayQueue。 将 String 数据和 de
Java延迟队列——DelayQueue
qq_25046827的博客
09-04 8690
DelayQueue是一个无界的BlockingQueue，是线程安全的（无界指的是队列的元素数量不存在上限，队列的容量会随着元素数量的增加而扩容，阻塞队列指的是当队列内元素数量为0的时候，试图从队列内获取元素的线程将被阻塞或者抛出异常）以上是阻塞队列的特点，而延迟队列还拥有自己如下的特点：DelayQueue中存入的必须是实现了Delayed接口的对象。
java延迟队列
一万年太久 - 只争朝夕
12-30 9918
在使用延迟队列之前，大多数用到定时执行的功能都是用任务调度来做的，但是当碰到类似订餐业务/购物等这种业务就不好处理了，比如购物的订单功能，在你的订单管理中有N个订单，当订单超过十分钟未支付的时候自动释放购物篮中的商品，订单失效。这种高频率的延迟任务再来用任务调度(定时)实现就得不偿失了。 推荐使用java 延迟队里来实现： 前提先了解线程，队列。 DelayQueue是java.util.c
Java - 延迟队列
c3VueXVl的博客
05-04 551
Task.javapublic class Task&lt;T extends Runnable&gt; implements Delayed { // 到期时间 private final long time; // 任务 private final T task; // 用于标识当前任务 private final long n; private final Ato...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值