Java 并发编程 - Delay（Delayed 概述、Delayed 实现、Delayed 使用、Delay 缓存实现、Delayed 延迟获取数据实现）

最新推荐文章于 2025-11-16 16:57:57 发布
原创 最新推荐文章于 2025-11-16 16:57:57 发布 · 815 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #缓存 #开发语言 #java-ee #后端 #intellij-idea #intellij idea

一、Delayed 概述

public interface Delayed extends Comparable<Delayed> {

    long getDelay(TimeUnit unit);
}

  1. Delayed 用于表示在给定延迟时间之后应该被处理的对象

  2. 核心方法 getDelay 用于返回指定时间单位的剩余的延迟时间，正数表示延迟尚未到期，0 或负数表示延迟已到期

  3. Delay 继承了 Comparable<Delayed> 接口，需要同时实现 compareTo 方法

  4. Delayed 通常与 DelayQueue 结合使用

二、Delayed 实现

  • MyDelayedTask.java
public class MyDelayedTask implements Delayed {

    private final long baseTime;  // 基准时间，通常为创建时间
    private final long delay;     // 延迟时长
    private final TimeUnit unit;  // 时间单位

    public MyDelayedTask(long delay, TimeUnit unit) {
        this.baseTime = System.nanoTime();
        this.delay = delay;
        this.unit = unit;
    }

    @Override
    public long getDelay(TimeUnit requestedUnit) {

        // 计算已经过去的时间
        long elapsed = System.nanoTime() - baseTime;

        // 计算总延迟的纳秒数
        long totalDelayNanos = unit.toNanos(delay);

        // 计算剩余延迟
        long remaining = totalDelayNanos - elapsed;

        // 转换为请求的时间单位
        return requestedUnit.convert(remaining, TimeUnit.NANOSECONDS);
    }

    @Override
    public int compareTo(Delayed other) {

        // 统一转换为纳秒进行比较
        long myDelay = this.getDelay(TimeUnit.NANOSECONDS);
        long otherDelay = other.getDelay(TimeUnit.NANOSECONDS);
        return Long.compare(myDelay, otherDelay);
    }
}
  • SimpleDelayedTask.java
public class SimpleDelayedTask implements Delayed {

    private final String data;
    private final long startTime;
    private final long delayNanos;

    public SimpleDelayedTask(String data, long delay, TimeUnit unit) {
        this.data = data;
        this.startTime = System.nanoTime();
        this.delayNanos = unit.toNanos(delay);
    }

    @Override
    public long getDelay(TimeUnit unit) {

        // 计算过去的延迟时间
        long elapsed = System.nanoTime() - startTime;

        // 计算剩余的延迟时间
        long remaining = delayNanos - elapsed;

        // 转换为指定的时间单位
        return unit.convert(remaining, TimeUnit.NANOSECONDS);
    }

    @Override
    public int compareTo(Delayed other) {
        if (this == other) return 0;

        // 统一转换为纳秒进行比较
        long thisDelay = this.getDelay(TimeUnit.NANOSECONDS);
        long otherDelay = other.getDelay(TimeUnit.NANOSECONDS);

        return Long.compare(thisDelay, otherDelay);
    }

    public String getData() {
        long delay = this.getDelay(TimeUnit.NANOSECONDS);
        if (delay <= 0) {
            return data;
        } else {
            return null;
        }
    }
}

三、Delayed 使用

1、基本使用
SimpleDelayedTask simpleDelayedTask = new SimpleDelayedTask("test content", 3, TimeUnit.SECONDS);

while (true) {
    String data = simpleDelayedTask.getData();
    if (data != null) {
        System.out.println("任务就绪，执行任务，获取到数据: " + data);
        break;
    } else {
        System.out.println("任务还未就绪，等待中...");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

# 输出结果

任务还未就绪，等待中...
任务还未就绪，等待中...
任务还未就绪，等待中...
任务还未就绪，等待中...
任务还未就绪，等待中...
任务还未就绪，等待中...
任务就绪，执行任务，获取到数据: test content

SimpleDelayedTask task1 = new SimpleDelayedTask("task1", 2, TimeUnit.SECONDS);
SimpleDelayedTask task2 = new SimpleDelayedTask("task2", 4, TimeUnit.SECONDS);
SimpleDelayedTask task3 = new SimpleDelayedTask("task3", 1, TimeUnit.SECONDS);

boolean task1Done = false;
boolean task2Done = false;
boolean task3Done = false;

while (!task1Done || !task2Done || !task3Done) {
    if (!task1Done) {
        String data = task1.getData();
        if (data != null) {
            System.out.println("任务 1 完成: " + data);
            task1Done = true;
        }
    }

    if (!task2Done) {
        String data = task2.getData();
        if (data != null) {
            System.out.println("任务 2 完成: " + data);
            task2Done = true;
        }
    }

    if (!task3Done) {
        String data = task3.getData();
        if (data != null) {
            System.out.println("任务 3 完成: " + data);
            task3Done = true;
        }
    }

    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

System.out.println("所有任务完成");

# 输出结果

任务 3 完成: task3
任务 1 完成: task1
任务 2 完成: task2
所有任务完成
2、结合 DelayQueue 使用
DelayQueue<SimpleDelayedTask> delayQueue = new DelayQueue<>();

delayQueue.add(new SimpleDelayedTask("test content1", 2, TimeUnit.SECONDS));
delayQueue.add(new SimpleDelayedTask("test content2", 4, TimeUnit.SECONDS));
delayQueue.add(new SimpleDelayedTask("test content3", 1, TimeUnit.SECONDS));

while (!delayQueue.isEmpty()) {
    try {
        SimpleDelayedTask simpleDelayedTask = delayQueue.take();

        System.out.println("任务就绪，执行任务，获取到数据: " + simpleDelayedTask.getData());
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

# 输出结果

任务就绪，执行任务，获取到数据: test content3
任务就绪，执行任务，获取到数据: test content1
任务就绪，执行任务，获取到数据: test content2

四、Delay 缓存实现

1、基本实现
  1. Delayed 实现，CacheItem.java
public class CacheItem implements Delayed {

    private final String data;
    private final long startTime;
    private final long delayNanos;

    public CacheItem(String data, long delay, TimeUnit unit) {
        this.data = data;
        this.startTime = System.nanoTime();
        this.delayNanos = unit.toNanos(delay);
    }

    @Override
    public long getDelay(TimeUnit unit) {
        long elapsed = System.nanoTime() - startTime;
        long remaining = delayNanos - elapsed;
        return unit.convert(remaining, TimeUnit.NANOSECONDS);
    }

    @Override
    public int compareTo(Delayed other) {
        if (this == other) return 0;

        // 统一转换为纳秒进行比较
        long thisDelay = this.getDelay(TimeUnit.NANOSECONDS);
        long otherDelay = other.getDelay(TimeUnit.NANOSECONDS);

        return Long.compare(thisDelay, otherDelay);
    }

    public String getData() {
        long delay = this.getDelay(TimeUnit.NANOSECONDS);
        if (delay <= 0) {
            return null;
        } else {
            return data;
        }
    }
}
  1. Test
CacheItem cacheItem = new CacheItem("test content", 3, TimeUnit.SECONDS);

while (true) {
    String data = cacheItem.getData();
    if (data != null) {
        System.out.println("缓存未过期，获取到数据: " + data);
    } else {
        System.out.println("缓存已过期");
        break;
    }

    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

# 输出结果

缓存未过期，获取到数据: test content
缓存未过期，获取到数据: test content
缓存未过期，获取到数据: test content
缓存未过期，获取到数据: test content
缓存未过期，获取到数据: test content
缓存未过期，获取到数据: test content
缓存已过期
2、缓存管理器
  1. SimpleCacheManager.java
public class SimpleCacheManager {

    private final Map<String, CacheItem> cacheItemMap = new ConcurrentHashMap<>();

    public void put(String key, String value, long ttl, TimeUnit unit) {
        cacheItemMap.put(key, new CacheItem(value, ttl, unit));
        System.out.println("缓存设置: " + key + " -> " + value + " (TTL: " + ttl + " " + unit + ")");
    }

    public void remove(String key) {
        cacheItemMap.remove(key);
        System.out.println("缓存移除: " + key);
    }

    public String get(String key) {
        CacheItem item = cacheItemMap.get(key);
        if (item != null) {
            return item.getData();
        }
        return null;
    }

    public void clean() {
        cacheItemMap.values().removeIf(item -> item.getDelay(TimeUnit.NANOSECONDS) <= 0);
    }
}
  1. Test
SimpleCacheManager simpleCacheManager = new SimpleCacheManager();

simpleCacheManager.put("user:A", "用户 A 信息", 3, TimeUnit.SECONDS);
simpleCacheManager.put("config:app", "应用配置", 5, TimeUnit.SECONDS);

for (int i = 0; i < 8; i++) {
    System.out.println("=== 第 " + (i + 1) + " 次查询 ===");

    String userData = simpleCacheManager.get("user:A");
    System.out.println("user:A -> " + userData);

    String configData = simpleCacheManager.get("config:app");
    System.out.println("config:app -> " + configData);

    simpleCacheManager.clean();

    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

# 输出结果

缓存设置: user:A -> 用户 A 信息 (TTL: 3 SECONDS)
缓存设置: config:app -> 应用配置 (TTL: 5 SECONDS)
=== 第 1 次查询 ===
user:A -> 用户 A 信息
config:app -> 应用配置
=== 第 2 次查询 ===
user:A -> 用户 A 信息
config:app -> 应用配置
=== 第 3 次查询 ===
user:A -> 用户 A 信息
config:app -> 应用配置
=== 第 4 次查询 ===
user:A -> null
config:app -> 应用配置
=== 第 5 次查询 ===
user:A -> null
config:app -> 应用配置
=== 第 6 次查询 ===
user:A -> null
config:app -> null
=== 第 7 次查询 ===
user:A -> null
config:app -> null
=== 第 8 次查询 ===
user:A -> null
config:app -> null
3、可重置缓存时间
  1. Delayed 实现，MyCacheItem.java
public class MyCacheItem implements Delayed {

    private final String data;
    private long startTime;
    private long delayNanos;

    public MyCacheItem(String data, long delay, TimeUnit unit) {
        this.data = data;
        this.startTime = System.nanoTime();
        this.delayNanos = unit.toNanos(delay);
    }

    @Override
    public long getDelay(TimeUnit unit) {
        long elapsed = System.nanoTime() - startTime;
        long remaining = delayNanos - elapsed;
        return unit.convert(remaining, TimeUnit.NANOSECONDS);
    }

    @Override
    public int compareTo(Delayed other) {
        if (this == other) return 0;

        // 统一转换为纳秒进行比较
        long thisDelay = this.getDelay(TimeUnit.NANOSECONDS);
        long otherDelay = other.getDelay(TimeUnit.NANOSECONDS);

        return Long.compare(thisDelay, otherDelay);
    }

    public String getData() {
        long delay = this.getDelay(TimeUnit.NANOSECONDS);
        if (delay <= 0) {
            return null;
        } else {
            return data;
        }
    }

    public boolean resetDelay(long delay, TimeUnit unit) {
        if (getDelay(TimeUnit.NANOSECONDS) <= 0) {
            return false;
        }

        // 重置缓存时间
        this.startTime = System.nanoTime();
        this.delayNanos = unit.toNanos(delay);
        return true;
    }
}
  1. Test
MyCacheItem myCacheItem = new MyCacheItem("test content", 3, TimeUnit.SECONDS);

int queryCount = 0;

while (true) {

    // 在第 3 次查询时，重置缓存过期时间为 5 秒
    queryCount++;
    System.out.println("=== 第 " + (queryCount) + " 次查询 ===");
    if (queryCount == 3) {
        System.out.println("重置缓存过期时间为 5 秒");
        myCacheItem.resetDelay(5, TimeUnit.SECONDS);
    }

    String data = myCacheItem.getData();
    if (data != null) {
        System.out.println("缓存未过期，获取到数据: " + data);
    } else {
        System.out.println("缓存已过期");
        break;
    }

    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

# 输出结果

=== 第 1 次查询 ===
缓存未过期，获取到数据: test content
=== 第 2 次查询 ===
缓存未过期，获取到数据: test content
=== 第 3 次查询 ===
重置缓存过期时间为 5 秒
缓存未过期，获取到数据: test content
=== 第 4 次查询 ===
缓存未过期，获取到数据: test content
=== 第 5 次查询 ===
缓存未过期，获取到数据: test content
=== 第 6 次查询 ===
缓存未过期，获取到数据: test content
=== 第 7 次查询 ===
缓存未过期，获取到数据: test content
=== 第 8 次查询 ===
缓存未过期，获取到数据: test content
=== 第 9 次查询 ===
缓存未过期，获取到数据: test content
=== 第 10 次查询 ===
缓存未过期，获取到数据: test content
=== 第 11 次查询 ===
缓存未过期，获取到数据: test content
=== 第 12 次查询 ===
缓存未过期，获取到数据: test content
=== 第 13 次查询 ===
缓存已过期

五、Delayed 延迟获取数据实现

  1. Delayed 实现，MakeTask.java
public class MakeTask implements Delayed {

    private final String data;
    private final long startTime;
    private final long delayNanos;

    public MakeTask(String data, long delay, TimeUnit unit) {
        this.data = data;
        this.startTime = System.nanoTime();
        this.delayNanos = unit.toNanos(delay);
    }

    @Override
    public long getDelay(TimeUnit unit) {
        long elapsed = System.nanoTime() - startTime;
        long remaining = delayNanos - elapsed;
        return unit.convert(remaining, TimeUnit.NANOSECONDS);
    }

    @Override
    public int compareTo(Delayed other) {
        if (this == other) return 0;

        // 统一转换为纳秒进行比较
        long thisDelay = this.getDelay(TimeUnit.NANOSECONDS);
        long otherDelay = other.getDelay(TimeUnit.NANOSECONDS);

        return Long.compare(thisDelay, otherDelay);
    }

    public String getData() {
        long delay = this.getDelay(TimeUnit.NANOSECONDS);
        if (delay <= 0) {
            return data;
        } else {
            return null;
        }
    }
}
  1. Test
MakeTask makeTask = new MakeTask("稿子", 3, TimeUnit.SECONDS);

while (true) {
    String data = makeTask.getData();
    if (data != null) {
        System.out.println("制作完成，获取到道具: " + data);
        break;
    } else {
        System.out.println("还未制作完成，等待中...");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

# 输出结果

还未制作完成，等待中...
还未制作完成，等待中...
还未制作完成，等待中...
还未制作完成，等待中...
还未制作完成，等待中...
还未制作完成，等待中...
制作完成，获取到道具: 稿子
java delayed实例_Java延迟队列原理与用法实例详解
weixin_30346649的博客
02-16 2559
本文实例讲述了Java延迟队列原理与用法。分享给大家供大家参考，具体如下：延时队列，第一他是个队列，所以具有对列功能第二就是延时，这就是延时对列，功能也就是将任务放在该延时对列中，只有到了延时时刻才能从该延时对列中获取任务否则获取不到……应用场景比较多，比如延时1分钟发短信，延时1分钟再次执行等，下面先看看延时队列demo之后再看延时队列在项目中的使用：简单的延时队列要有三部分：第一实现了Dela...
Java高并发专题之35、延迟队列 DelayQueue 详解
CSDN_KONGlX的博客
05-04 1946
目录 1. 前言 在我的项目中有这样一个场景：页面链接是同一个，但是可以有多个子页面，不同的时间要展示不同子页面，类似一个页面排期功能。也许你们觉得要实现这个功能比较简单，实现过程为：获取所有子页面的生效时间，对每个生效时间点创建一个定时器，每个定时器执行内容为使用新的子页面进行渲染。对于单个或者少量页面这样做完全没有问题，但是在我的项目中每天都有上万个这样的页面需要进行排期。如果采用这种方...
Java使用 Delayed 实现延迟任务
半只
02-19 5093
创建一个 Delayed 抽象类并且实现Runnable接口 /** * 延迟任务抽象 */ public abstract class Task implements Delayed, Runnable{ private String id = ""; private long start = 0; /** * * @param id 任务ID, 用于区分不同任务 * @param delayInMilliseconds 延迟毫秒 *
java 简单实现延时队列 DelayQueue
weixin_49834195的博客
01-03 833
【代码】java 简单实现延时队列 DelayQueue。
java实现延迟消息的几种方式
SHENMU1的博客
10-08 2344
一些消息或任务我们可能不希望立即执行, 希望在一定时间后或者某个时间点的前一定时间执行, 即在某个时间点执行某个任务。
springboot +java延时任务（Delayed）
leaning_java的博客
04-28 6058
springboot +java延时任务（Delayed）
Delay-dependent filtering for discrete-time state-delayed systems with small gain conditions in finite frequency ranges
02-21
通过将非凸的滤波综合条件转换为基于LMIs的形式，可以利用已有的优化工具对这些条件进行有效求解，这大大简化了在实际系统中实现延迟依赖滤波器的难度。 在研究中，Xiao-Ni Zhang和Guang-Hong Yang两位研究者不仅...
rabbitmq-delayed-message-exchange-3.8.0.tar.gz
09-08
在这个场景中，我们关注的是RabbitMQ的一个特殊插件——"rabbitmq-delayed-message-exchange"，它允许我们在RabbitMQ中实现延迟消息的功能。延迟消息是指消息在发送后不会立即被消费者处理，而是会在设定的时间间隔...
A Modified EXP3 and Its Adaptive Variant in Adversarial Bandits with Multi-User Delayed Feedback
04-13
使用场景及目标：①适用于需要处理多用户延迟反馈的在线推荐系统、在线广告投放等实际应用场景；②帮助研究者理解如何在对抗性环境中应对延迟反馈带来的挑战；③提供了一种有效的方法来优化在动态环境中的决策过程，...
rabbitmq_delayed_3.6.x延迟插件.rar
12-23
一旦启用，用户可以在声明交换机时指定"x-delayed-message"类型，并在发布消息时添加一个特殊的头域，如`x-delay`，来设置延迟时间（以毫秒为单位）。 以下是一些关于如何使用RabbitMQ延迟队列的详细步骤和示例： ...
java利用delayedQueue实现本地的延迟队列
08-30
主要给大家介绍了java利用delayedQueue实现本地的延迟队列的相关资料，文中介绍的非常详细，相信对大家具有一定的参考价值，需要的朋友们下面来一起看看吧。
rabbitmq-delayed-message-exchange-4.0.2
10-17
rabbitmq延迟插件
Java JDK的DelayedQueue实现延迟任务
Programmer__Chen的博客
02-06 770
Java JDK的DelayedQueue实现延迟任务，定时推送
【应用篇】---史上最全的延迟任务实现方式汇总！
没有伞的孩子必须努力奔跑！—小林
04-23 1323
不用谢我，送人玫瑰，手有余香。相信接下来的内容一定不会让你失望，因为它将是目前市面上最好的关于“延迟任务”的文章，这也一直是我写作追求的目标，让我的每一篇文章都比市面上的好那么一点点。 好了，话不多说，直接进入今天的主题，本文的主要内容如下图所示： 什么是延迟任务？ 顾明思议，我们把需要延迟执行的任务叫做延迟任务。 延迟任务的使用场景有以下这些： 红包 24 小时未被查收，需要延...
java实现延迟/超时/定时
yuzheh521的博客
01-08 4529
方法获取任务的时候，会拿到队列头部的元素，也就是队列中最早需要被执行的任务，通过getDelay返回值判断任务是否需要被立刻执行，如果需要的话，就返回任务，如果不需要就会等待这个任务到延迟时间的剩余时间，当时间到了就会将任务返回。，list数据类型，被称为目标队列，这个里面存放的任务都是已经到了延迟时间的，可以被消费者获取的任务，所以上面demo中的RBlockingQueue的take方法是从这个目标队列中获取到任务的。这里面就有这么一个channel叫做。图中channel理解成MQ中的topic。
【JAVA】深入了解 Java 中的 DelayQueue
AliceNo的博客
01-04 1896
Java中的DelayQueue是一个强大的工具，常用于处理需要延迟执行的任务或具有过期时间的元素。通过实现Delayed接口，DelayQueue提供了一种灵活而高效的方式来管理具有不同延迟的元素。本文将深入介绍DelayQueue的使用，包括其基本原理、适用场景和示例代码。通过学习这些内容，你将更好地理解和应用DelayQueue，从而提升你在并发编程和任务调度方面的技能。Delayed接口是包中的一个接口，它继承自Comparable接口。Delayed接口要求实现类提供一个方法。
Java延迟消息队列DelayQueue使用和管理工具类DelayQueueUtil实现
leaderFLY的博客
04-06 962
摄像头布防核心处理类 代码 package com.emdata.videomonitor.biz.thread.camera; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import com.emdata.videomonitor.common.utils.Guid; import lombok.Data; import lombok.extern.slf4j.Slf4j; import org.a
【Java笔记】实现延时队列（小结）：JDK DelayQueue&MQ&Redis
Hansdas的博客
03-31 2360
RabbitMQ中消息或队列具有一个属性，TTL（Time To Live），表明一条消息或者队列中的所有消息的最大存活时间// 设置队列的TTL// 设置每条消息的TTL如果同时配置了队列的TTL和消息的TTL，就用较小值如果设置队列的TTL：消息过期就会被队列遗弃如果设置消息的TTL：消息过期会在即将送给消费者时确定，不会马上丢弃不设置TTL：消息永不过期如果将TTL设置为0：如果不能马上给到消费者就会被丢弃稍微总结一下延迟队列主要用于xxx事件之后/之前，执行xxx。
【Java 微服务中间件】RabbitMQ 全方位解析：同步异步对比、SpringAMQT基础入门、实战、交换机类型及消息处理详解
最新发布
Varin
11-16 1396
文档全面解析 RabbitMQ，涵盖同步异步对比、基础入门、Java 实战、交换机类型、队列交换机声明及消息转换器等内容，为 RabbitMQ 学习与应用提供指导。
Rails引擎Delayed::Web：轻松实现Delayed::Job的Web界面
文档中提供的标签"Ruby", "ruby-gem", "ruby-on-rails", "Delayed-job"表明了Delayed::Web与Ruby语言、Ruby gems包管理器、Ruby on Rails框架和Delayed::Job库的紧密关联。 9. 压缩包文件名称列表： "delayed-web...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值