JDK自带的延迟队列——DelayQueue

最新推荐文章于 2024-09-09 09:32:08 发布
最新推荐文章于 2024-09-09 09:32:08 发布
阅读量1.4k 收藏 24
点赞数 27
分类专栏： java 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kersixy/article/details/135562005
版权

DelayQueue是基于阻塞队列实现的，是JDK自带延迟队列。这种方案使用成本最低，而且不依赖任何第三方服务，减少了网络交互。但缺点也很明显，就是需要占用JVM内存，在数据量非常大的情况下可能会有问题。如果数据量非常大，DelayQueue不能满足业务需求，也可以替换为其它延迟队列方式，例如Redisson、MQ等。

1. DelayQueue的原理

首先来看一下DelayQueue的源码：

public class DelayQueue<E extends Delayed> extends AbstractQueue<E>​
    implements BlockingQueue<E> {​
​
    private final transient ReentrantLock lock = new ReentrantLock();​
    private final PriorityQueue<E> q = new PriorityQueue<E>();​
    ​
    // ... 略​
}

可以看到DelayQueue实现了BlockingQueue接口，是一个阻塞队列。队列就是容器，用来存储东西的。DelayQueue叫做延迟队列，其中存储的就是延迟执行的任务。

我们可以看到DelayQueue的泛型定义：

DelayQueue<E extends Delayed>

这说明存入 DelayQueue 内部的元素必须是 Delayed 类型，这其实就是一个延迟任务的规范接口。来看一下：

public interface Delayed extends Comparable<Delayed> {

    /**
     * Returns the remaining delay associated with this object, in the
     * given time unit.
     *
     * @param unit the time unit
     * @return the remaining delay; zero or negative values indicate
     * that the delay has already elapsed
     */
    long getDelay(TimeUnit unit);
}

从源码中可以看出，Delayed类型必须具备两个方法：

  • getDelay() : 获取延迟任务的剩余延迟时间
  • compareTo( T t ) : 比较两个延迟任务的延迟时间，判断执行顺序

可见，Delayed类型的延迟任务具备两个功能：获取剩余延迟时间、比较执行顺序。当然，我们可以对Delayed做实现和功能扩展，比如添加延迟任务的数据。

将来每一次提交数据，就可以将数据保存在这样的一个 Delayed 类型的延迟任务里并设定延迟时间。然后交给 DelayQueue 队列。 DelayQueue 会调用compareTo方法，根据剩余延迟时间对任务排序。剩余延迟时间越短的越靠近队首，这样就会被优先执行。

2. DelayQueue 的基本使用

2.1 创建 Delayed 的实现类

import lombok.Data;

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

@Data
public class DelayedTask implements Delayed {
    // 消息体
    private Object data;
    // 过期时间
    private Long deadTime;

    /**
     * 到期时间，毫秒
     */
    public DelayedTask(Object data, Long expireTime) {
        this.data = data;
        this.deadTime = System.currentTimeMillis() + expireTime * 1000;
    }

    /**
     * 获取元素的剩余的有效期
     */
    @Override
    public long getDelay(TimeUnit unit) {
        long remain = this.deadTime - System.currentTimeMillis();
        if (remain < 0) {
            remain = 0;
        }
        return unit.convert(remain, TimeUnit.MILLISECONDS);
    }

    /**
     * 比较元素的剩余，看谁先到期
     */
    @Override
    public int compareTo(Delayed o) {
        long l = this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS);
        if (l > 0) {
            return 1;
        } else if (l < 0) {
            return -1;
        } else {
            return 0;
        }
    }
}

2.2 向列队发送消息并接收

import com.example.delayedqueuedemo.task.DelayedTask;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.DelayQueue;

@Slf4j
public class DelayedQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        // 1.初始化延迟队列
        DelayQueue<DelayedTask> delayQueue = new DelayQueue<>();
        DelayedTask task1 = new DelayedTask("data 5 seconds", 5L);
        DelayedTask task2 = new DelayedTask("data 1 seconds", 1L);
        DelayedTask task3 = new DelayedTask("data 3 seconds", 3L);
        // 2.向队列中添加延迟执行的任务
        delayQueue.put(task1);
        delayQueue.put(task2);
        delayQueue.put(task3);
        // 3.尝试执行任务
        log.info("消息发送完成");
        // 如果队列中没有到期的元素，take会阻塞等待
        while (true) {
            DelayedTask task = delayQueue.take();
            log.info("获取延迟任务：task：{}", task.getData());
        }
    }
}

3. 实际项目应用

3.1 将发送端和接收端分离

在实际项目中，需要将发送端和接收端分离，避免死循环的队列接收阻塞主程序运行，故将列队接收代码抽离到 Spring 在生命周期回调期间执行，具体代码如下：

import com.example.delayedqueuedemo.task.DelayedTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class DelayedService {
    private ThreadPoolExecutor takeTaskPool = new ThreadPoolExecutor(1, 1, 120, TimeUnit.SECONDS, new ArrayBlockingQueue<>(1));
    private ThreadPoolExecutor executeTaskPool = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), Runtime.getRuntime().availableProcessors(), 120, TimeUnit.SECONDS, new ArrayBlockingQueue<>(Runtime.getRuntime().availableProcessors()), new ThreadPoolExecutor.CallerRunsPolicy());
    private DelayQueue<DelayedTask> delayQueue = new DelayQueue<>();

    /**
     * 生命周期回调
     */
    @PostConstruct
    public void postConstruct() {
        // 开启线程池，避免死循环阻塞主程序
        takeTaskPool.execute(new Runnable() {
            @Override
            public void run() {
                // 如果队列中没有到期的元素，take会阻塞等待
                while (true) {
                    try {
                        DelayedTask task = delayQueue.take();
                        // 为了防止业务逻辑执行太长，阻塞消息的读取
                        executeTaskPool.execute(new Runnable() {
                            @Override
                            public void run() {
                                // 执行业务代码
                                log.info("获取延迟任务：task：{}", task.getData());
                            }
                        });
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }

    public void delayed(String data, Long expireTime) {
        // 1.初始化延迟队列
        DelayedTask task = new DelayedTask(data, expireTime);
        // 2.向队列中添加延迟执行的任务
        delayQueue.put(task);
        // 3.尝试执行任务
        log.info("消息发送完成");
    }
}

3.2 开启事务

若需要开启事务支持，直接用 @Transactional 注解会出现事务失效的情况（@Transactional 失效场景可参考该文章： 一口气怼完12种@Transactional的失效场景 - 知乎 ），故有两种方法解决：

  1. 将业务代码写到新的 service 服务中，让 Spring 代理；
  2. 编程式事务处理

以下代码以编程式事务处理方案演示如何开启事务：

import com.example.delayedqueuedemo.task.DelayedTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionException;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import javax.annotation.PostConstruct;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class DelayedService {
    private ThreadPoolExecutor takeTaskPool = new ThreadPoolExecutor(1, 1, 120, TimeUnit.SECONDS, new ArrayBlockingQueue<>(1));
    private ThreadPoolExecutor executeTaskPool = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), Runtime.getRuntime().availableProcessors(), 120, TimeUnit.SECONDS, new ArrayBlockingQueue<>(Runtime.getRuntime().availableProcessors()), new ThreadPoolExecutor.CallerRunsPolicy());
    private DelayQueue<DelayedTask> delayQueue = new DelayQueue<>();
    @Autowired
    private PlatformTransactionManager transactionManager;

    /**
     * 生命周期回调
     */
    @PostConstruct
    public void postConstruct() {
        // 开启线程池，避免死循环阻塞主程序
        takeTaskPool.execute(new Runnable() {
            @Override
            public void run() {
                // 如果队列中没有到期的元素，take会阻塞等待
                while (true) {
                    try {
                        DelayedTask task = delayQueue.take();
                        // 开启线程池，避免业务执行阻塞队列获取消息，核心线程数根据电脑cpu核数而定
                        executeTaskPool.execute(new Runnable() {
                            @Override
                            public void run() {
                                // 开启事务
                                TransactionDefinition definition = new DefaultTransactionDefinition();
                                TransactionStatus transaction = transactionManager.getTransaction(definition);
                                try {
                                    // 业务逻辑
                                    log.info("获取延迟任务：task：{}", task.getData());
                                    // 提交事务
                                    transactionManager.commit(transaction);
                                } catch (TransactionException e) {
                                    // 回滚事务
                                    transactionManager.rollback(transaction);
                                }
                            }
                        });
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }

    @Transactional
    public void delayed(String data, Long expireTime) {
        // 1.初始化延迟队列
        DelayedTask task = new DelayedTask(data, expireTime);
        // 2.向队列中添加延迟执行的任务
        delayQueue.put(task);
        // 3.尝试执行任务
        log.info("消息发送完成");
    }
}

可儿·四系桜
关注
专栏目录
延时任务通知服务的设计及实现（三）-- JDK的延迟队列DelayQueue
天草二十六
04-29 1195
作为进程内的延迟队列，在多点部署的分布式集群环境下， 代码明显比上一篇要复杂得多。任务的生产任务的消费移除任务应用启动的时候拉取回调时间将近的未完成任务（更新marked标记为true，防止重复拉取冷数据）定时拉取未标记且回调时间将近的未完成任务（和上面必须是互斥，等待上一步执行完成，否则会导致重复拉取）删除延迟队列DelayQueue的任务，必须发布广播消息给全部节点。（引入广播消息机制）
DelayQueue源码解析
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
11-22 187
DelayQueue是JUC包(java.util.concurrent)为我们提供的延迟队列，它是一个基于PriorityQueue实现的一个无界队列，是一个线程安全的延迟队列。PriorityQueue源码分析当我们希望某个任务在某个时间才能取出并操作时，我们就可以让这个继承Delayed接口，实现其计算任务到期时间的方法 getDelay。然后将任务存放到 DelayQueue 中,默认情况下, DelayQueue 会按照到期时间升序编排任务。
Java 本地延迟队列DelayQueue的实现
星辰大海中的路人乙的博客
12-01 430
项目背景： 最近做的项目有个需求：生成一则工单推送给用户后，等待用户处理。15分钟后再查询工单的状态，如果超时未处理，则推送一则超时工单消息通知用户。 实现的方式很多，这里不做讨论。由于项目规模不是很大，这里不想引入MQ中间件，增加系统复杂度。所以用JDK 提供的DelayQueue 实现了一把延迟队列 ~~ 代码实现： import java.util.concurrent.Delayed; import java.util.concurrent.TimeUnit; /** * @au...
DelayQueue（JDK自带的延时队列）
最新发布
wlcass zhengge blog
09-09 934
DelayQueue是一个无界的BlockingQueue，用于放置实现了Delayed接口的对象，其中的对象只能在其到期时才能从队列中取走。这种队列是有序的，即队头对象的延迟到期时间最长。注意：不能将null元素放置到这种队列中。方法抛出异常返回值一直阻塞超时退出插入方法addofferput移除方法removepolltakePoll(time)检查方法elementpeekN/AN/A。
延迟队列--DelayQueue(JDK)
'传琦'博客
06-12 1253
DelayQueue:是一种支持延时获取元素的无界阻塞队列。特性：线程安全；内部元素有“延迟”特性:只有延迟到期的元素才允许被获取；具有优先级特性的无界队列，优先级以元素延迟时间为标准，最先过期的元素优先级最高（队首）;入队操作不会被阻塞，获取元素在特定情况会阻塞（队列为空，队首元素延迟未到期等）;根据其源码分析为何如此定义以及其特性的由来。DelayQueue继承关系：类图分析：其核心继承/实现：1.BlockingQueue:说明其具有阻塞队列的特性；
JDK自带的延迟队列
qq_33378714的博客
02-28 596
【代码】JDK自带的延迟队列。
Jdk的延时队列
奔跑的菜鸡
10-18 1378
工作上一般能用jdk自带功能的直接拿来用就可以，以免出现各种bug DelayQueue JDK 中提供了一组实现延迟队列的API，位于Java.util.concurrent包下DelayQueue。 DelayQueue是一个BlockingQueue（无界阻塞）队列，它本质就是封装了一个PriorityQueue（优先队列），PriorityQueue内部使用完全二叉堆（来实现队列元素排序，我们在向DelayQueue队列中添加元素时，会给元素一个Delay（延迟时间）作为排序条件，队列中最小的元素会
JDK延时队列介绍与实战
胖虎儿的博客
11-30 593
jdk 延时队列介绍与实战
业务日记——延时队列/延时消费
Luffyu的博客
05-11 1140
一、基本定义 延时/定时消息是指生产者(producer)发送消息到server后，server并不将消息立即发送给消费者(consumer)，而是在producer指定的时间之后送达。 二、常用的使用场景 任务超时处理。例如 订单系统中，如果某个用户在 30分钟内没有支付，则订单自动进行过期处理 任务延时处理。例如订餐系统中，下单成功60s之后 给用户发短信通知 定时任务。例如现在通过手机...
Java 源码剖析(10)--手写一个消息队列和延迟消息队列
姜皓的博客
07-11 1295
手写一个消息队列和延迟消息队列1）消息队列的使用场景1.1）商品秒杀1.2）系统解耦1.3）日志记录2）消息中间件 RabbitMQ3）手写一个消息队列和延迟消息队列 1）消息队列的使用场景 1.1）商品秒杀 在做秒杀活动时，会发生短时间内出现爆发式的用户请求，如果不采取相关的措施，会导致服务器忙不过来，响应超时的问题，轻则会导致服务假死，重则会让服务器直接宕机，给用户带来的体验也非常不好。如果这个时候加上了消息队列，服务器接收到用户的所有请求后，先把这些请求全部写入到消息队列中再排队处理，这样就不会导致同
构建高性能队列，你不得不知道的底层知识！
彤哥读源码
08-15 364
前言 本文收录于专辑：http://dwz.win/HjK，点击解锁更多数据结构与算法的知识。 你好，我是彤哥。 上一节，我们一起学习了如何将递归改写为非递归，其中，用到的数据结构主要是栈。 栈和队列，可以说是除了数组和链表之外最基础的数据结构了，在很多场景中都有用到，后面我们也会陆陆续续的看到。 今天，我想介绍一下，在Java中，如何构建一个高性能的队列，以及我们需要掌握的底层知识。 学习其他语言的同学，也可以看看，在你的语言中，是如何构建高性能队列的。 队列 队列，是一种先进先出（First In
DelayQueue
01-24
学习视频，可以丰富java知识。能够获得更多的专业技能
随笔系列之延时队列
是程序媛不是程序猿
08-17 657
广义上来说，延时队列存在多种不同实现方式，每种实现方式对延时队列又有着不同的定义。但是，无论其怎么定义，延时队列总有一个共性，能够使进入队列的消息被延迟消费。 一、背景介绍 1、何为延时队列 广义上来说，延时队列存在多种不同实现方式，每种实现方式对延时队列又有着不同的定义。比如，JDK中juc包下，自带的DelayQueue是这么定义的： “DelayQueue是一个无界的BlockingQueue，用于放置实现了Delayed接口的对象。其中的对象只能在其到期时才能从队列中取走” —— Think .
基于JDK-DelayQueue实现的延迟队列
qq_48157004的博客
08-20 2058
延迟元素的无限制BlockingQueu，其中元素只能在其延迟到期后才能获取。当元素的getDelay（TimeUnit.NANOSECONDS）方法返回小于或等于零的值时，就会发生过期。即使未到期的元素无法使用take或poll删除，它们也被视为普通元素。业务处理类（DelayTask）实现Delayed接口。2. 当订单数量过多会出现OOM异常现象。1. 服务器重启数据会全部丢失。重点 take（）方法解析。如果用于在取消订单中。
JDK的DelayQueue
吕世良
10-28 498
Java中的DelayQueue位于java.util.concurrent包下，作为单机实现，它很好的实现了延迟一段时间后触发事件的需求。由于是线程安全的它可以有多个消费者和多个生产者，从而在某些情况下可以提升性能。DelayQueue本质是封装了一个PriorityQueue，使之线程安全，加上Delay功能，也就是说，消费者线程只能在队列中的消息“过期”之后才能返回数据获取到消息，不然只能获取到null。 之所以要用到PriorityQueue，主要是需要排序。也许后插入的消息需要比队列中的其他消息
JDK中的延迟队列DelayQueue
WannaRunning的博客
09-02 502
JDK中java.util.concurrent包下的DelayQueue是基于过期时间段实现可延迟消费的目的。 DelayQueue内部基于可排序的PriorityQueue优先队列来实现的,但是PriorityQueue本身是非线程安全的,所以DelayQueue在实现上通过加ReentrantLock的方式保证线程安全,同时出队和入队都是使用的同一把锁，所以出入队操作不能同时执行。 消息入队 public class DelayQueue<E extends Delayed> e.
DelayQueue实现原理及应用场景分析
热门推荐
山不转的博客
04-02 2万+
DelayQueue基本原理 DelayQueue是一个没有边界BlockingQueue实现，加入其中的元素必需实现Delayed接口。当生产者线程调用put之类的方法加入元素时，会触发Delayed接口中的compareTo方法进行排序，也就是说队列中元素的顺序是按到期时间排序的，而非它们进入队列的顺序。排在队列头部的元素是最早到期的，越往后到期时间赿晚。 消费者线程查看队列头部的元素，注...
JDK容器学习之Queue：DelayQueue
weixin_33804990的博客
10-25 219
2019独角兽企业重金招聘Python工程师标准>>> ...
通过JDK自带的工具实现延迟队列
qq_35829103的博客
03-19 334
通过JDK自带的工具实现延迟队列
jdk自带log启动，查找配置文件
06-09
如果你想要查找 JDK 自带 log 的启动配置文件，可以按照以下步骤进行操作： 1. 打开 JDK 的安装目录，找到 jre 目录下的 lib 文件夹； 2. 在 lib 文件夹中，找到 logging.properties 配置文件； 3. 打开 logging.properties 文件，里面包含了 JDK 自带 log 的启动配置信息。 请注意，如果你想要修改 JDK 自带 log 的启动配置，可以直接修改 logging.properties 文件。但是建议备份原始配置文件，以防止配置错误导致问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值