Java最新java实现延时处理(1)，绝对干货分享

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量817 收藏 18
点赞数 29
分类专栏： 程序员 文章标签： java 面试 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84692641/article/details/138694354
版权

最后总结

ActiveMQ+Kafka+RabbitMQ学习笔记PDF

image.png

  • RabbitMQ实战指南

image.png

  • 手写RocketMQ笔记

image.png

  • 手写“Kafka笔记”

image

关于分布式，限流+缓存+缓存，这三大技术（包含：ZooKeeper+Nginx+MongoDB+memcached+Redis+ActiveMQ+Kafka+RabbitMQ）等等。这些相关的面试也好，还有手写以及学习的笔记PDF，都是啃透分布式技术必不可少的宝藏。以上的每一个专题每一个小分类都有相关的介绍，并且小编也已经将其整理成PDF啦

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

在这里插入图片描述

时间轮算法可以类比于时钟，如上图箭头（指针）按某一个方向按固定频率轮动，每一次跳动称为一个 tick。

这样可以看出定时轮由个3个重要的属性参数，ticksPerWheel（一轮的tick数），tickDuration（一个tick的持续时间）以及 timeUnit（时间单位）

例如当ticksPerWheel=60，tickDuration=1，timeUnit=秒，这就和现实中的始终的秒针走动完全类似了。

如果当前指针指在1上面，我有一个任务需要4秒以后执行，那么这个执行的线程回调或者消息将会被放在5上。

那如果需要在20秒之后执行怎么办，由于这个环形结构槽数只到8，如果要20秒，指针需要多转2圈。位置是在2圈之后的5上面（20 % 8 + 1）

3.2 实现

我们用Netty的HashedWheelTimer来实现

3.2.1 添加maven依赖

io.netty

netty-all

5.0.0.Alpha2

3.2.2 具体实现

import io.netty.util.HashedWheelTimer;

import io.netty.util.Timeout;

import io.netty.util.Timer;

import io.netty.util.TimerTask;

import java.util.concurrent.TimeUnit;

public class HashedWheelTimerTest {

static class MyTimerTask implements TimerTask{

boolean flag;

public MyTimerTask(boolean flag){

this.flag = flag;

}

public void run(Timeout timeout) throws Exception {

// TODO Auto-generated method stub

System.out.println(“要去数据库删除订单了。。。。”);

this.flag =false;

}

}

public static void main(String[] argv) {

MyTimerTask timerTask = new MyTimerTask(true);

Timer timer = new HashedWheelTimer();

timer.newTimeout(timerTask, 3, TimeUnit.SECONDS);//此处设置在时间轮第几个执行（本代码设置为第3格）

int i = 1;

while(timerTask.flag){

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(i+“秒过去了”);

i++;

}

}

}

测试结果如下：

在这里插入图片描述

3.3 优缺点

  • 优点:效率高,任务触发时间延迟时间比delayQueue低，代码复杂度比delayQueue低。

  • 缺点:

(1)服务器重启后，数据全部消失，怕宕机

(2)集群扩展相当麻烦

(3)因为内存条件限制的原因，比如下单未付款的订单数太多，那么很容易就出现OOM异常

4.redis缓存

======================================================================

对于redis缓存的实现我们有两种方式：

  • 1.利用redis的zset,zset是一个有序集合，每一个元素(member)都关联了一个score,通过score排序来取集合中的值

  • 2.使用redis的Keyspace Notifications（键空间机制），就是利用该机制可以在key失效之后，提供一个回调，实际上是redis会给客户端发送一个消息。

4.1 利用redis的zset

添加元素:ZADD key score member [[score member] [score member] …]

按顺序查询元素:ZRANGE key start stop [WITHSCORES]

查询元素score:ZSCORE key member

移除元素:ZREM key member [member …]

下面我通过实操来给大家演示一下

添加单个元素

redis> ZADD page_rank 10 google.com

添加多个元素

redis> ZADD page_rank 9 baidu.com 8 bing.com

(integer) 2

在这里插入图片描述

按顺序查询元素 0 -1表示查询所有

ZRANGE page_rank 0 -1 WITHSCORES

在这里插入图片描述

查询元素的score值

redis> ZSCORE page_rank bing.com

在这里插入图片描述

移除单个元素

redis> ZREM page_rank google.com

在这里插入图片描述

在这里插入图片描述

我们具体将其和和我们要实现的功能联系在一起呢?

在这里插入图片描述

4.1.1 添加redis依赖

org.springframework.boot

spring-boot-starter-redis

1.4.7.RELEASE

具体的实现如下：

import java.util.Calendar;

import java.util.Set;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.Tuple;

public class AppTest {

private static final String ADDR = “192.168.1.2”;

private static final int PORT = 6379;

private static JedisPool jedisPool = new JedisPool(ADDR, PORT);

private static int waitTime = 10;//以10秒为基准

public static Jedis getJedis() {

return jedisPool.getResource();

}

//生产者,生成5个订单放进去

public void productionDelayMessage() {

long startTime = System.currentTimeMillis();

for (int i = 0; i < 5; i++) {

//延迟3秒

Calendar cal1 = Calendar.getInstance();

waitTime += 5;//每个订单之间的间隔为5秒

cal1.add(Calendar.SECOND, waitTime);

int second3later = (int) (cal1.getTimeInMillis() / 1000);

AppTest.getJedis().zadd(“OrderId”, second3later, “OID0000001” + i);

long endTime = System.currentTimeMillis();

System.out.println((endTime - startTime) / 1000 + “s:redis生成了一个订单任务：订单ID为” + “OID0000001” + i);

}

}

//消费者，取订单

public void consumerDelayMessage() {

Jedis jedis = AppTest.getJedis();

long startTime = System.currentTimeMillis();

while (true) {

Set items = jedis.zrangeWithScores(“OrderId”, 0, 1);

if (items == null || items.isEmpty()) {

System.out.println(“当前没有等待的任务”);

try {

Thread.sleep(500);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

continue;

}

int score = (int) ((Tuple) items.toArray()[0]).getScore();

Calendar cal = Calendar.getInstance();

int nowSecond = (int) (cal.getTimeInMillis() / 1000);

if (nowSecond >= score) {

String orderId = ((Tuple) items.toArray()[0]).getElement();

jedis.zrem(“OrderId”, orderId);

long endTime = System.currentTimeMillis();

System.out.println((endTime - startTime) / 1000 + “s:redis消费了一个任务：消费的订单OrderId为” + orderId);

}

}

}

public static void main(String[] args) {

AppTest appTest = new AppTest();

appTest.productionDelayMessage();//创建消费订单

appTest.consumerDelayMessage();//由消费者进行消费

}

}

测试结果如下：

在这里插入图片描述

通过上述结果我们可以看出每隔5秒消费了一笔订单

然而上面的实现却有一个致命的问题： 在高并发条件下，多消费者会取到同一个订单号

我们使用多线程进行测试一下

import java.util.concurrent.CountDownLatch;

public class ThreadTest {

private static final int threadNum = 10;//线程数

private static CountDownLatch cdl = new CountDownLatch(threadNum);

static class DelayMessage implements Runnable {

public void run() {

try {

cdl.await();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

AppTest appTest = new AppTest();

appTest.consumerDelayMessage();

}

}

public static void main(String[] args) {

AppTest appTest = new AppTest();

appTest.productionDelayMessage();

for (int i = 0; i < threadNum; i++) {

new Thread(new DelayMessage()).start();

cdl.countDown();

}

}

}

在这里插入图片描述

可以看出出现了多个线程消费同一个资源的情况，这种情况肯定是不允许的，所以给出两个解决方案让大家参考

  • 1.用分布式锁，但是用分布式锁，性能下降了

  • 2.对ZREM的返回值进行判断，只有大于0的时候，才消费数据

由于方案1涉及到java分布式锁的设计，后面我会专门出一期关于java分布式锁的内容讲解，同时也会将第一个方法的内容补全，下面我们先看看如何通过ZREM来进行解决多线程消费同一个订单的问题

4.1.2 解决多线程消费同一资源

我们将consumerDelayMessage()方法中的

在这里插入图片描述

改为以下内容

if (nowSecond >= score) {

String orderId = ((Tuple) items.toArray()[0]).getElement();

Long num = jedis.zrem(“OrderId”, orderId);

long endTime = System.currentTimeMillis();

if (num != null && num > 0) {

System.out.println((endTime - startTime) / 1000 + “s:redis消费了一个任务：消费的订单OrderId为” + orderId);

}

}

再次进行多线程的测试

在这里插入图片描述

4.2 使用redis的Keyspace Notifications（键空间机制）

在redis的配置文件中(redis.conf)中，加入以下配置

notify-keyspace-events Ex

具体操作代码如下：

package com.example.test.test;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPubSub;

public class RedisTest {

private static final String ADDR = “192.168.1.2”;

private static final int PORT = 6379;

private static JedisPool jedis = new JedisPool(ADDR, PORT);

private static RedisSub sub = new RedisSub();

public static void init() {

new Thread(new Runnable() {

public void run() {

jedis.getResource().subscribe(sub, “keyevent@0:expired”);

}

}).start();

}

public static void main(String[] args) throws InterruptedException {

init();

for (int i = 0; i < 10; i++) {

String orderId = “OID000000” + i;

jedis.getResource().setex(orderId, 3, orderId);

更多：Java进阶核心知识集

包含：JVM，JAVA集合，网络，JAVA多线程并发，JAVA基础，Spring原理，微服务，Zookeeper，Kafka，RabbitMQ，Hbase，MongoDB，Cassandra，设计模式，负载均衡，数据库，一致性哈希，JAVA算法，数据结构，加密算法，分布式缓存等等

image

高效学习视频

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

private static RedisSub sub = new RedisSub();

public static void init() {

new Thread(new Runnable() {

public void run() {

jedis.getResource().subscribe(sub, “keyevent@0:expired”);

}

}).start();

}

public static void main(String[] args) throws InterruptedException {

init();

for (int i = 0; i < 10; i++) {

String orderId = “OID000000” + i;

jedis.getResource().setex(orderId, 3, orderId);

更多：Java进阶核心知识集

包含：JVM，JAVA集合，网络，JAVA多线程并发，JAVA基础，Spring原理，微服务，Zookeeper，Kafka，RabbitMQ，Hbase，MongoDB，Cassandra，设计模式，负载均衡，数据库，一致性哈希，JAVA算法，数据结构，加密算法，分布式缓存等等

[外链图片转存中…(img-BMVeIpev-1715378040961)]

高效学习视频

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

2401_84692641
关注
  • 29
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中程序延迟执行的两种方式
Crime_man的博客
03-19 874
通常是执行延迟或定期任务的首选方式，因为它具有更好的错误处理能力，并且提供了线程池支持。变量是延迟时间，以毫秒为单位，这里设置为10分钟（10 * 60 * 1000毫秒）。如果一个任务的执行时间过长，可能会影响到后续任务的准时执行。是连续任务执行之间的时间（以毫秒为单位）。如果你需要这个任务定期执行，可以使用。类时，所有的定时任务都会由一个。安排在10分钟后执行。
Java程序中的延迟加载功能使用
09-03
主要介绍了Java程序中的延迟加载功能使用,一定程度上有助于提升性能和降低内存使用率,需要的朋友可以参考下
定时任务和延迟任务，Java中实现延迟任务
m0_63102097的博客
06-17 2135
定时任务指的是在预定的时间或间隔内执行特定任务或代码的过程。它是一种常见的编程需求，用于执行周期性的操作、定时触发事件以及处理需要延迟执行的任务。在软件开发中，定时任务通常用于处理后台数据处理、系统维护、报表生成、数据备份等任务。
Java谓词的延迟执行
最佳 Java 编程
06-10 163
在先前的文章“ 用Java的供应商延迟执行 ”和“ Java的消费者延迟执行 “，我看着很容易地通过推迟标准Java API接受，分别在Java执行供应商 S和消费者秒。 在本文中，我将对标准JDK提供的API如何通过标准功能接口Predicate允许延迟执行进行类似的研究。 Predicate 在其Javadoc中进行了描述 ，“代表一个参数的谓词（布尔值函数）。” 换句话说， Predi...
java延迟执行方法,Java中的一些延迟后的调用方法
weixin_30229479的博客
02-12 658
Scenario is like :In my application, I opened one file, updated it and saved. Once the file saved event get fired and it will execute one method abc().But now, I want to add delay after save event get...
带有Java Util日志记录的Java 8延迟调用
最佳 Java 编程
06-02 211
在博客文章“在Log4j2中更好地执行非日志记录器调用”中 ，我介绍了可以在Log4j 2中使用的方法，这些方法可以减少或避免在基于指定日志级别实际上根本未记录的日志语句中调用方法。 作为讨论的一部分，我介绍了Log4j 2对使用lambda表达式的基于Java 8的延迟执行的支持。 在本文中，我将演示如何使用内置的java.util.logging （ JUL ）支持来使用lambda表达...
java让程序延迟执行_Java运行时延迟执行程序
weixin_39984105的博客
02-28 597
我有一个JButton，它有一个重写的actionPerformed(event)函数，如下所示：public void actionPerformed(ActionEvent event) {try {System.out.println("enters here");Process p = Runtime.getRuntime().exec("python tetris.py");} catc...
Java实现任务超时处理方法
08-25
Java实现任务超时处理方法是指在Java中对超时任务的处理，主要有两种方式：基于异步任务结果的超时获取和使用延时任务来终止超时操作。 基于异步任务结果的超时获取是通过使用Future对象来实现的。在提交任务时，会...
一口气说出Java 6种延时队列的实现方法(面试官也得服)
08-19
Java 延时队列的实现方法 延时队列是一种特殊的队列，它可以根据指定的延迟时间来消费队列中的消息。在 Java 中，实现延时队列有多种方式，以下是六种常见的实现方法： 1. DelayQueue 延时队列 DelayQueue 是 ...
Java自带定时任务ScheduledThreadPoolExecutor实现定时器和延时加载功能
08-26
下面是一个延时1秒后执行的示例，假设我们有一个`RolePrvlegeTask`实现了`Callable`接口： ```java RolePrvlegeTask task = (RolePrvlegeTask) SpringUtils.getBean("rolePrvlegeTask"); stThread.schedule(task, 1...
java利用delayedQueue实现本地的延迟队列
08-30
Java 利用 DelayedQueue 实现本地的延迟队列 DelayedQueue 是 Java 中的一种特殊的阻塞队列，它用于存放实现了 Delayed 接口的对象。这种队列是有序的，即队头对象的延迟到期时间最长。 DelayedQueue 能够满足我们...
java实现一个小程序语句的延迟执行的小demo
08-19
由于个人需要使用，结合API和网友们的相关介绍，自己写了一个小小的demo可以通过java实现一个小程序语句的延迟执行，希望给需要的人提供帮助吧。
Java 两种延时thread和timer详解及实例代码
08-31
主要介绍了Java 两种延时thread和timer详解及实例代码的相关资料,需要的朋友可以参考下
Java如何处理延迟任务过程解析
08-25
延迟任务是指需要在特定时间执行的任务，例如延时1分钟发短信、延时1分钟再次执行等。 Java提供了多种方式来处理延迟任务，其中之一就是使用延迟队列。 延迟队列是一种特殊的队列，它可以将任务延迟到特定的时间后...
java多线程之延迟初始化
学无止境的博客
06-30 648
有时候我们可能推迟一些高开销的对象的初始化操作，并且只有在使用这些对象时才进行初始化，开发者可以采用延迟初始化来实现该需求。但是要正确实现线程安全的延迟初始化还是需要一些技巧的，否则很容易出现问题。下面是一个非线程安全的延迟初始化的例子： public class UnsafeLazyInit { private static Instance instance; public st
java如何设置延迟执行_如何因为java中的某些条件而调用函数来延迟执行？
weixin_30979229的博客
02-28 535
这是我的运行方法，它打开一个套接字，并等待接受的连接，如果连接被接受，将有一个单独的线程打开执行它：while (isKeepRun) {socket = serverSocket.accept();WorkTask worktask = new WorkTask();worktask.setSocket(socket);worktask.setIn(new ObjectInputStream(s...
【项目实战】并发编程之Java中使用五种方式实现延时执行调用
本本本添哥
04-19 2435
To实现延时执行调用，Java中可以使用Thread.sleep()方法。该方法接受一个以毫秒为单位的时间参数，使当前线程休眠指定的时间。在休眠期间，线程不会执行任何操作。在上面的代码块中，使用try-catch块来捕获InterruptedException异常。这是因为Thread.sleep()方法可能会抛出该异常，如果线程在休眠期间被中断，则会抛出该异常。在catch块中，我们简单地打印了异常堆栈跟踪，但您可以根据需要采取其他措施。
java实现延迟/超时/定时
yuzheh521的博客
01-08 2699
方法获取任务的时候，会拿到队列头部的元素，也就是队列中最早需要被执行的任务，通过getDelay返回值判断任务是否需要被立刻执行，如果需要的话，就返回任务，如果不需要就会等待这个任务到延迟时间的剩余时间，当时间到了就会将任务返回。，list数据类型，被称为目标队列，这个里面存放的任务都是已经到了延迟时间的，可以被消费者获取的任务，所以上面demo中的RBlockingQueue的take方法是从这个目标队列中获取到任务的。这里面就有这么一个channel叫做。图中channel理解成MQ中的topic。
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 845
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
java redis实现延时队列
06-28
### 回答1： 延时队列是指队列中的任务需要在一定延时后才能被执行，可以有效地解决某些任务需要延时处理的问题。Java Redis是一个基于Redis的Java客户端，它可以实现Java语言对Redis数据结构的操作，因此可以很方便地实现延时队列的功能。 Java Redis实现延时队列的主要思路是利用Redis的Sorted Set数据结构，将任务按照延时时间作为Score，任务内容作为Value，插入Sorted Set中，并设置过期时间，过期后将任务弹出并执行。具体实现步骤如下： 1. 创建一个Sorted Set，将任务插入其中，Score为任务的延时时间，Value为任务的内容。 2. 使用Redis的zremrangebyscore命令扫描Sorted Set中Score小于等于当前时间的任务并弹出，并将任务内容推送到执行队列中。 3. 设置延时任务的过期时间，过期时间为延时时间加当前时间，可以使用Redis的zadd命令添加任务时同时设置Score和过期时间。 4. 执行队列按顺序执行任务，任务执行完成后从执行队列中删除。 通过以上步骤，可以实现一个高效可靠的延时队列，可以优化系统任务调度、异步处理、消息通知等场景下的问题。 ### 回答2： Java Redis延时队列是一种常用的消息队列模式，在很多应用场景中都有应用。Java Redis延时队列通过将消息发送到Redis进行存储，在指定的时间后再将消息取出来进行处理。这个过程中，通过Redis的Sorted Set类型进行排序来保证队列中的消息有序。下面来详细介绍Java Redis延时队列的实现方式。 一、Redis数据结构 Java Redis延时队列的关键在于Redis数据结构的设计。在Redis中，Sorted Set就是用来解决排序问题的。所以我们需要借助Sorted Set实现延时队列。具体来说，可以使用Redis中的zadd命令将消息发送到Sorted Set中，并按照时间顺序进行排序。Sorted Set中的元素包含值和权重，我们可以根据权重（即时间戳）来实现有序存储。 二、消息入队 消息的入队过程如下： 1. 获取消息的过期时间TTL。 2. 计算出当前的时间戳now。 3. 将消息写入到Sorted Set中，权重为now+TTL。 ```redis-cli> ZADD delay-queue (now + TTL) message``` 三、消息出队 消息出队过程如下： 1. 获取当前时间戳now。 2. 使用zrangebyscore命令从Sorted Set中获取所有权重小于等于now的元素，即过期的元素。 3. 遍历查询结果，对每个元素执行出队操作（移除元素）。 ```redis-cli> ZRANGEBYSCORE delay-queue -inf now``` 四、多线程处理 为避免在出队过程中同时处理多个过期元素时出现问题，可以使用多线程处理消息。Java的并发包中提供了Executor框架，这里可以使用ThreadPoolExecutor线程池。 五、消息重试 有时候由于网络波动等原因，在执行消息处理时可能会失败，所以需要将失败的消息重新入队。此时，可以加入重试机制，重新入队时TTL加上重试时间，即可实现延时次数的控制。 六、总结 Java Redis延时队列利用Redis的Sorted Set实现有序存储，使用多线程和重试机制解决了消息处理时的并发和失败问题，保障了消息的可靠性。在实际应用中，可以根据业务需求进行调优和扩展，如设置合理的时间间隔、增加监控和报警等。 ### 回答3： Java Redis实现延时队列可以分为以下几步： 1.将任务加入到延时队列中：首先需要将任务和对应的过期时间放入Redis的有序集合中，以过期时间为score值，任务为value。这样可以保证按照过期时间顺序进行排序，具有先进先出的特点。代码实现如下： ```java //添加任务到延时队列 public void addToDelayQueue(String taskId, long delayTime) { //计算过期时间 long expireTime = System.currentTimeMillis() + delayTime; //添加到有序集合中，score为过期时间 jedis.zadd(DELAY_QUEUE_KEY, expireTime, taskId); } ``` 2.从延时队列中取出任务：需要循环从有序集合中取出第一个score小于等于当前时间的任务，并将其从有序集合中删除。代码实现如下： ```java //获取延时队列中的任务 public void getFromDelayQueue() { while (true) { //获取第一个score小于等于当前时间的任务 Set<String> set = jedis.zrangeByScore(DELAY_QUEUE_KEY, 0, System.currentTimeMillis(), 0, 1); if (set == null || set.isEmpty()) { try { Thread.sleep(1000);//如果没有取到任务，则等待1秒 } catch (InterruptedException e) { e.printStackTrace(); } continue; } String taskId = set.iterator().next(); //删除任务 jedis.zrem(DELAY_QUEUE_KEY, taskId); //处理任务 handleTask(taskId); } } //处理任务 public void handleTask(String taskId) { //TODO: 根据taskId执行对应的任务 } ``` 3.使用Redis发布订阅机制以及线程池来处理任务：在处理任务时，可以使用Redis发布订阅机制将任务相关的信息发布到指定的频道，由相应的消费者线程池来进行任务处理，可以降低单线程处理任务的压力。代码实现如下： ```java //处理任务 public void handleTask(String taskId) { //通过发布订阅机制将任务信息发布到指定频道 jedis.publish(TASK_CHANNEL, taskId); } //消费者线程池处理任务 public void consumeTask() { JedisPubSub jedisPubSub = new JedisPubSub() { public void onMessage(String channel, String message) { //TODO: 根据message信息执行对应的任务 } }; jedis.subscribe(jedisPubSub, TASK_CHANNEL); executorService.execute(jedisPubSub::quit); } ``` 通过以上步骤，我们就可以实现Java Redis延时队列的功能，实现了任务的延迟执行。延时队列的实现可以实现具有任务按照时间顺序执行，且任务可取消、可重试等特点，应用场景广泛。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值