引言
在我的项目中有这样一个场景：页面链接是同一个，但是可以有多个子页面，不同的时间要展示不同子页面，类似一个页面排期功能。也许你们觉得要实现这个功能比较简单，实现过程为：获取所有子页面的生效时间，对每个生效时间点创建一个定时器，每个定时器执行内容为使用新的子页面进行渲染。对于单个或者少量页面这样做完全没有问题，但是在我的项目中每天都有上万个这样的页面需要进行排期。如果采用这种方式，势必会创建上万个定时器放到jvm内存，这显然是不科学的。
我们的做法是把 每个子页面排期看成是一个任务放到任务表，任务执行时间即为子页面的开始时间，再通过一个分布式任务调度器，每次获取将来5分钟内即将执行的任务列表。把这些任务放到一个DelayQueue中，每个子页面开始时间到达时，从DelayQueue中取出，执行页面渲染，这时用户浏览到的页面就是最新的内容。
这里通过分布式任务调度器，可以把任务均分到各个服务器上，并且每次获取任务是指取将来5分钟内即将执行的任务列表，这个列表一般不会太多，可以直接放到队列中。当然如果很多也没关系，可以指定获取最大任务条数。通过上述处理可以控制放入DelayQueue的任务数，减少不必要的内存消耗。如下图：假如5分钟内即将执行的任务列表有9个，通过分布式调度分配到每台机器上的任务数即为3个：
关于分布式任务调度，可以使用淘宝的tbschedule等类似的框架支持，也可以自己实现。这里不详细讲解分布式任务调度怎么实现，今天的主角是DelayQueue—延迟队列。
现在我们已经获取到每台机器上的即将执行的任务列表，接下来就是把这些任务放到DelayQueue，通过其take方法获取到期的任务定时执行。
DelayQueue基本特征
DelayQueue延迟队列同时具备：无界队列、阻塞队列、优先队列的特征。分别来看下：
无界队列：通过调用DelayQueue的offer方法（或add方法），把待执行的任务对象放入队列，该方法是非阻塞的。这个队列是无界队列，内存足够的情况下，理论上存放的任务对象数是无限的。
阻塞队列：DelayQueue实现了BlockingQueue接口，是一个阻塞队列。但该队列只是在取对象时阻塞，对应两个方法：1、take()方法，获取并移除队列头的对象，如果时间还未到，就阻塞等待。2、poll(long timeout, TimeUnit unit) 方法，阻塞时间长度为timeout，然后获取并移除队列头的对象，如果对象延迟时间还未到，就返回null。
优先队列：DelayQueue的一个重要的成员是一个优先队列PriorityQueue，PriorityQueue内部是一个二叉小顶堆实现，其特点就是头部元素对应的权值是队列中最小的，也就是通过poll()方法获取到的对象是最优先的。
Delayed接口
DelayQueue延迟队列中存放的对象，必须是实现Delayed接口的类对象。Delayed接口，是Comparable的子类：
public interface Delayed extends Comparable<Delayed>
所有要实现Delayed接口必须重写其getDelay、compareTo方法。看一个实现例子：
public class TaskInfo implements Delayed {
//任务id
private int id;
//业务类型
private int type;
//业务数据
private String data;
//执行时间
private long excuteTime;
public TaskInfo(int id, int type, String data, long excuteTime) {
this.id = id;
this.type = type;
this.data = data;
this.excuteTime = TimeUnit.NANOSECONDS.convert(excuteTime, TimeUnit.MILLISECONDS)+System.nanoTime();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
public long getExcuteTime() {
return excuteTime;
}
public void setExcuteTime(long excuteTime) {
this.excuteTime = excuteTime;
}
@Override
public long getDelay(TimeUnit unit) {
return unit.convert(this.excuteTime- System.nanoTime() , TimeUnit.NANOSECONDS);
}
@Override
public int compareTo(Delayed o) {
TaskInfo msg = (TaskInfo)o;
return this.excuteTime>msg.excuteTime?1:( this.excuteTime<msg.excuteTime?-1:0);
}
}
通过DelayQueue的offer方法加入对象是，会根据对象compareTo方法把对象放到优先队列PriorityQueue中的指定位置；通过DelayQueue的take方法获取对象时，会调用对象的getDelay方法，确定延迟获取时间，需要注意的是这里的时间单位为纳秒，示例代码中通过unit.convert(this.excuteTime- System.nanoTime() , TimeUnit.NANOSECONDS)进行转换。
DelayQueue使用示例
public class DelayTest {
private static DelayQueue<TaskInfo> queue = new DelayQueue<>();//延迟队列
private static ExecutorService es = Executors.newFixedThreadPool(3);//3个线程的线程池
public static void main(String[] args){
while (true) {
try {
if (queue.size() <=0){
//获取任务放入队列
getTask();
if(queue.size() <= 0){
System.out.println("没有任务睡眠10秒");
//没有任务睡眠10秒
Thread.sleep(10*1000);
}
}else{
TaskInfo task = queue.take();
es.submit(()->{
System.out.println("执行任务：" + task.getId() + ":" + task.getData());
});
}
}catch (Exception e){
e.printStackTrace();
}
}
}
//模拟从数据库获取 将来10秒中内即将执行的任务
public static void getTask(){
Random r = new Random();
int t = r.nextInt(2);
if(t==0){
return;
}
TaskInfo t1 = new TaskInfo(1,1,"任务1",1000);
TaskInfo t2 = new TaskInfo(2,2,"任务2",2000);
TaskInfo t3 = new TaskInfo(3,3,"任务3",3000);
TaskInfo t4 = new TaskInfo(4,4,"任务4",4000);
TaskInfo t5 = new TaskInfo(5,5,"任务5",5000);
TaskInfo t6 = new TaskInfo(6,6,"任务6",6000);
TaskInfo t7 = new TaskInfo(7,7,"任务7",7000);
TaskInfo t8 = new TaskInfo(8,8,"任务8",8000);
queue.offer(t1);
queue.offer(t2);
queue.offer(t3);
queue.offer(t4);
queue.offer(t5);
queue.offer(t6);
queue.offer(t7);
queue.offer(t8);
}
}
示例代码讲解：
1、首先创建了一个DelayQueue的延迟队列；并通过Executors.newFixedThreadPool(3)创建了一个3个线程数的线程池。
2、main方法循环体中判断如果队列中没有对象，就模拟从数据库中获取10秒内即将执行的任务，并放入DelayQueue。如果数据库中没有10秒内即将执行的任务，程序睡眠10秒。
3、如果队列中有对象，调用DelayQueue的take()方法，获取到期的任务信息，并把任务信息交给线程池进行处理。
实例中，模拟创建了8个任务，每个任务的延迟执行时间分别为1到8秒。
执行main方法，每隔1秒打印一条信息，打印完整信息如下：
执行任务：1:任务1 执行任务：2:任务2 执行任务：3:任务3 执行任务：4:任务4 执行任务：5:任务5 执行任务：6:任务6 执行任务：7:任务7 执行任务：8:任务8
测试结果符合我们的预期，这个测试示例其实就是文章开头业务场景的简化版实现。
DelayQueue源码解析
首先看下DelayQueue的成员变量：
//为了保证线程安全：对队列中每次存取操作，都需要进行加锁，采用的重入锁
private final transient ReentrantLock lock = new ReentrantLock();
//优先队列，延迟对象最终放到改队列中，保证每次从头部取出的对象，是应该最先被执行的
private final PriorityQueue<E> q = new PriorityQueue<E>();
//leader线程，其等待延迟时间为优先队列中，最优先对象的延迟时间。其他线程无限期等待
private Thread leader = null;
//配合重入锁使用，对线程进行等待，唤醒等操作
private final Condition available = lock.newCondition();
三个加入队列方法
add、offer、put三个加入队列方法，其中add和put都是直接调用offer方法，所以调用三个方法中的任意一个都是等效的。首先看下offer方法：
public boolean offer(E e) {
final ReentrantLock lock = this.lock;
lock.lock();//加锁
try {
q.offer(e);//调用PriorityQueue的offer方法，放入队列
if (q.peek() == e) {//判断刚加入的对象，是不是头节点
leader = null;
available.signal();//唤醒take()或poll(..)方法中的等待
}
return true;
} finally {
lock.unlock();//释放锁
}
}
这个方法最值得关注的地方是，放入队列后，判断刚放入队列的对象是不是PriorityQueue队列的头节点，如果是需要唤醒take()或poll(..)方法中的等待阻塞，重新获取头节点对象的延迟等待时间。
add、put方法都是直接调用offer方法，源码为：
public boolean add(E e) {
return offer(e);
}
public void put(E e) {
offer(e);
}
四个获取对象方法
poll()、poll(..)、take()、peek()这四个方法都可以实现从队列头获取一个对象，但每个方法实现都不相同。
peek()方法：非阻塞方法：
public E peek() {
final ReentrantLock lock = this.lock;
lock.lock();//加锁
try {
return q.peek();
} finally {
lock.unlock();//释放锁
}
}
DelayQueue的peek方法，本质上调用的是PriorityQueue的peek方法，只是多了一个加锁操作。该方法会返回头部节点对象，但不会从队列中移除。peek的含义为：瞟一眼。
poll()方法：从队列头部获取并移除一个对象，非阻塞方法，源码实现为：
public E poll() {
final ReentrantLock lock = this.lock;
lock.lock();//加锁
try {
E first = q.peek();//获取队列中的头节点对象（不会移除）
if (first == null || first.getDelay(NANOSECONDS) > 0)
return null;//调用对象的getDelay方法，如果延迟时间还未到，直接返回空
else
return q.poll();//如果延迟时间已经到达，直接调用PriorityQueue队列的取出并移除的poll方法
} finally {
lock.unlock();
}
}
poll()方法 首先调用peek方法获取到头节点对象，通过调用对象的getDelay方法判断延迟时间是否到达，如果没有到达返回null，否则调用PriorityQueue的poll方法 取出并移除头节点对象 并返回。
take()方法：DelayQueue的核心方法，常用于任务延迟执行，是阻塞方法。源码为：
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();//加中断锁
try {
for (;;) {
E first = q.peek();//获取头节点
if (first == null)
available.await();//头结点为空，释放锁无限期等待，等待offer方法放入对象，再次获得锁
else {
long delay = first.getDelay(NANOSECONDS);//获取头节点对象延迟时间
if (delay <= 0)
return q.poll();//延迟时间已过，直接从队列中移除并取出返回
first = null; // don't retain ref while waiting
if (leader != null)
available.await();//如果不是leader线程，无限期等待
else {
Thread thisThread = Thread.currentThread();
leader = thisThread;//设置当前线程为leader线程
try {
available.awaitNanos(delay);//释放锁，等待头结点延迟时间到来，再获得锁。
} finally {
if (leader == thisThread)
leader = null;//释放leader线程引用
}
}
}
}
} finally {
if (leader == null && q.peek() != null)
available.signal();//唤醒某一个线程，获得锁，设置leader线程
lock.unlock();//释放锁
}
}
take方法主要实现逻辑为（for循环体）：
1、获取头节点对象，如果为空，线程释放锁，并进入无限期等待。等待offer方式，放入对象后，通过signal()方法唤醒。
2、如果头节点对象不为空，获取该对象的延迟时间，如果小于0，直接从队列中取出并移除该对象，返回。
3、如果头节点对象延迟时间大于0，判断是否“leader线程”是否已经存在，如果存在说明当前线程为“追随者线程”，进入无限期等待（等待leader线程take方法完成后，唤醒）。
4、如果“leader线程”不存在，把当前线程设置为“leader线程”，释放锁并等待头节点对象的延迟时间后，重新获得锁，下次循环获取头节点对象返回。
5、finally代码块，每次leader线程执行完成take方法后，需要唤醒其他线程获得锁成为新的leader线程。
take方法实现了一个“领导者-追随者模式”的线程处理方式，只有leader线程会等待指定时间后获得锁，其他线程都会进入无限期等待。这也是为什么在DelayQueue中都是使用signal唤醒，而不使用signalAll的原因（只需要一个线程成为leader线程）。
这个图，展示有3个线程调用DelayQueue的take方法，只会有一个线程成为”leader线程”，这里假设为线程1。其他两个线程为“追随者”，无限期等待，在”leader线程”执行完成之后调用signal方法随机唤醒一个线程成为新的”leader线程”。
poll(..)方法：带延迟参数的poll方法，是阻塞方法，源码为：
public E poll(long timeout, TimeUnit unit) throws InterruptedException {
long nanos = unit.toNanos(timeout);//把 指定延迟时间 转换成纳秒
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();//加中断锁
try {
for (;;) {
E first = q.peek();
if (first == null) {//如果头节点为空
if (nanos <= 0)
return null;//指定延迟时间 小于0直接返回null
else
nanos = available.awaitNanos(nanos);//等待 指定延迟时间后，再重新获得锁
} else {
long delay = first.getDelay(NANOSECONDS);//获取头节点对象的延迟时间
if (delay <= 0)
return q.poll();//如果对象延迟时间已过期，直接取出并移除该对象，返回
if (nanos <= 0)
return null;//如果对象延迟时间还未到，但指定延迟时间已到，返回null
first = null; // don't retain ref while waiting
if (nanos < delay || leader != null)
nanos = available.awaitNanos(nanos);//如果“指定延迟时间”小于“对象延迟时间”或者不是leader线程，等待指定时间后 再次被唤醒。
else {//如果“指定延迟时间”大于等于“对象延迟时间”并且 leader线程为空
Thread thisThread = Thread.currentThread();
leader = thisThread;//指定当前线程为leader线程
try {
long timeLeft = available.awaitNanos(delay);
nanos -= delay - timeLeft;//重新计算最新的 “指定延迟时间"
} finally {
if (leader == thisThread)
leader = null;
}
}
}
}
} finally {
if (leader == null && q.peek() != null)
available.signal();//leader线程执行结束后，唤醒某个“追随者”线程
lock.unlock();
}
}
poll(..)方法: 如果指定的延迟时间，小于头结点对象的延迟时间，返回为空，非阻塞。
如果指定的延迟时间，大于头结点对象的延迟时间，会阻塞，阻塞长度为头结点对象的延迟时间。这样说会比较抽象，看一个例子：
public class DelayTest2 {
private static DelayQueue<TaskInfo> queue = new DelayQueue<>();//延迟队列
public static void main(String[] args) throws Exception{
getTask();
for(int i=0;i<3;i++){//启动线程数
new Thread(new Runnable() {
@Override
public void run() {
try {
TaskInfo task = queue.poll(10000, TimeUnit.MILLISECONDS);//延迟时间
if(task == null){
System.out.println("任务为空");
}else {
System.out.println("执行任务：" + task.getId() + ":" + task.getData());
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
}
//模拟从数据库获取 将来10秒中内即将执行的任务
public static void getTask(){
TaskInfo t1 = new TaskInfo(1,1,"任务1",1000);
TaskInfo t2 = new TaskInfo(2,2,"任务2",2000);
TaskInfo t3 = new TaskInfo(3,3,"任务3",3000);
TaskInfo t4 = new TaskInfo(4,4,"任务4",4000);
TaskInfo t5 = new TaskInfo(5,5,"任务5",5000);
TaskInfo t6 = new TaskInfo(6,6,"任务6",6000);
TaskInfo t7 = new TaskInfo(7,7,"任务7",7000);
TaskInfo t8 = new TaskInfo(8,8,"任务8",8000);
queue.offer(t1);
queue.offer(t2);
queue.offer(t3);
queue.offer(t4);
queue.offer(t5);
queue.offer(t6);
queue.offer(t7);
queue.offer(t8);
}
}
该实例会启动3个线程同时调用queue.poll(10000, TimeUnit.MILLISECONDS)方法，其中一个线程会被设置为“leader线程”，等待时间为头结点的延迟时间，其他线程的等待时间都为10000ms。当“leader线程”执行完成后，会选择另外某个现在做为“leader线程”等待时间改为当前头结点的延迟时间。
执行这段代码的main方法，会每隔1秒打印一条信息，完整打印信息如下：
执行任务：1:任务1 执行任务：2:任务2 执行任务：3:任务3
如果把指定延迟时间改为500，即：queue.poll(500, TimeUnit.MILLISECONDS)，重新执行main()方法，该方法返回为空，这时不会阻塞，并立即打印三条消息：
任务为空 任务为空 任务为空
poll(..)方法的使用场景为：按指定时间段，分批次执行延迟队列中的任务。从源码上看，在指定延迟时间大于头节点对象延迟时间时的实现 跟take()方法很像，只是“追随者线程”的等待时间有区别：poll(..)方法是等待指定延迟时间，take()方法是无限期等待。
DelayQueue的其他方法都比较简单（remove，clear等），这里不再一一列举。
相关推荐
- **出队（take）**: 使用`take()`方法从`DelayQueue`中取出元素时，会阻塞直到队列中有元素的延迟时间已过，此时该元素会被移出队列并返回。如果队列为空，`take`操作会一直阻塞，直到有元素可用。 3. **线程安全...
local delayQueue implemented by JDK & two kinds of distributed delayQueue based redis 1. 基本介绍 RedisSynDelayQueue 基于redis，并发情况下会加分布式锁，单线程场景（syn=false）性能较好， 并发场景性能较...
Java并发包源码分析(JDK1.8)：囊括了java.util.concurrent包中大部分类的源码分析，其中涉及automic包，locks包(AbstractQueuedSynchronizer、ReentrantLock、ReentrantReadWriteLock、LockSupport等)，queue...
学习视频，可以丰富java知识。能够获得更多的专业技能
当DelayQueue中有可处理的订单时，从Redis中删除对应的键（即订单），并执行取消订单的业务逻辑。 5. 为了防止Redis中的订单过期但DelayQueue中仍有未处理的订单，可以使用一个单独的线程或服务定期扫描Redis中的已...
DelayQueue的使用以及注意事项，这里需要由BlockingQueue的基本知识，一般的Queue的使用方法poll(),take(),drainTo()和offer(),put()这些应该懂。
本文将深入探讨如何利用Java中的`DelayQueue`和Redis来实现这一功能。`DelayQueue`是Java并发库`java.util.concurrent`中的一个数据结构，它是一个基于优先级队列的无界阻塞队列，可以用于存储具有延迟时间的元素。...
该项目是SpringBoot框架下的延迟消息Starter，提供对DelayQueue、Redisson和RabbitMQ三种延迟消息机制的集成支持。项目包含32个文件，涵盖24个Java源文件、4个XML配置文件、1个Git忽略文件、1个Markdown文件、1个...
### RTSP Live555开源框架源码阅读笔记 #### 概述 Live555是一个广泛使用的开源项目，主要用于实现实时流协议(RTSP)。该项目支持多种媒体格式和编码方式，如H.264、MPEG-4等，并提供了丰富的API供开发者进行二次...
基于DelayQueue的简单的定时任务队列.zip Quick Start class Main { public static void main(String[] args) { // 初始化任务队列 JobScheduler scheduler = new JobScheduler("default"); // 向队列中提交任务...
DelayQueue的主要作用是按照对象的延迟时间来排序，以便在合适的时刻从队列中取出对象。 DelayQueue的使用非常广泛，例如在任务调度、网络编程、数据处理等领域都可以看到它的身影。 DelayQueue的使用示例 在上面...
Spring Boot延时任务之DelayQueue的使用详解 DelayQueue是一个无界阻塞队列，只有在延迟期满时，才能从中提取元素。它提供了在指定时间才能获取队列元素的功能，队列头元素是最接近过期的元素。DelayQueue的元素...
使用JDK自带的`DelayQueue`:** - **原理:** `DelayQueue` 是一个支持延时获取元素的阻塞队列，内部利用优先队列实现。 - **局限性:** 若程序异常中断，`DelayQueue` 中的任务将丢失。 - **2. 使用RabbitMQ实现...
java forkjoin 源码 -- -- geomesa -- spring -- 算法 ...[乐观锁&悲观锁，重入锁&非重入锁，公平锁&...[DelayQueue] 并发安全集合 [HashMap, ConcurrentHashMap源码] [ArrayList, LinkedList, CopyOnWriteArrayList源码]
源码可能包含了任务的创建、调度、消费等接口，以及与Redis交互的具体实现。同时，它可能还包含了单元测试和示例用例，帮助开发者理解和使用这个延迟队列。 总的来说，这个Go延迟队列项目结合了Go语言的并发优势和...
Java并发库中实现阻塞队列的主要类有ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue和DelayQueue等。它们在并发编程中起到缓冲和协调生产者与消费者线程的作用，实现高效的数据交换。 3. **线程...
ArrayList核心源码+扩容机制分析LinkedList核心源码分析HashMap核心源码+底层数据结构分析ConcurrentHashMap核心源码+底层数据结构分析...ArrayBlockingQueue核心源码分析PriorityQueue核心源码分析DelayQueue核心源码分析
Java并发编程常见知识点源码集锦，涉及到对象锁,Executors多任务线程框架,线程池等示例，列出一些源码包中包括的内容： volatile关键字的非原子性、volatile关键字的使用、AtomicInteger原子性操作、线程安全小...
- JDK 1.6之前使用循环链表，JDK 1.7取消循环。 ##### 2. `Set` - **HashSet** - 基于`HashMap`实现，使用`HashMap`存储元素。 - 特点：插入、删除和查找速度非常快，但不保证元素的顺序。 - **LinkedHashSet**...
2.在数据量大的情况下延时较高，规定内处理不完，影响业务，虽然可以启动多个进程来处理，这样会带来额外的维护成本，不能从根本上解决。 3.每个业务都要维护一个自己的扫表逻辑。 当业务越来越多时，发现扫表部分的...