public class MyTimerTask {

    public static void main(String[] args) {
        // 定義一個(gè)任務(wù)
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                System.out.println("Run timerTask：" + new Date());
            }
        };
        // 計(jì)時(shí)器
        Timer timer = new Timer();
        // 添加執(zhí)行任務(wù)（延遲 1s 執(zhí)行，每 3s 執(zhí)行一次）
        timer.schedule(timerTask, 1000, 3000);
    }
}

ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);

// 延遲 1s 后執(zhí)行
scheduler.schedule(() -> {
    System.out.println("Task executed once at: " + new Date());
}, 1, TimeUnit.SECONDS);

// 延遲 1s 后執(zhí)行，之后每 2s 執(zhí)行一次
scheduler.scheduleAtFixedRate(() -> {
    System.out.println("Fixed-rate task executed at: " + new Date());
}, 1, 2, TimeUnit.SECONDS);

@EnableScheduling
@SpringBootApplication
public class SpringbootApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(SpringbootApplication.class, args);
    }
}

@Component
public class TimerTask {
 
    @Scheduled(cron = "0 0 0 0 7 *")
    public void task() {
        System.out.println("定時(shí)任務(wù)...");
    }
}

// 1. 定義 Job
public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext context) {
        System.out.println("Quartz Job executed at: " + new Date());
    }
}

// 2. 配置 Trigger 和 Scheduler
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();

JobDetail job = JobBuilder.newJob(MyJob.class)
    .withIdentity("myJob", "group1")
    .build();

Trigger trigger = TriggerBuilder.newTrigger()
    .withIdentity("myTrigger", "group1")
    .startNow()
    .withSchedule(SimpleScheduleBuilder.simpleSchedule()
        .withIntervalInSeconds(5) // 每 5s 執(zhí)行一次
        .repeatForever())
    .build();

scheduler.scheduleJob(job, trigger);
scheduler.start();

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

public class DelayedTask implements Delayed {
    private final String taskName;
    private final long executeTime; // 執(zhí)行時(shí)間（毫秒時(shí)間戳）

    public DelayedTask(String taskName, long delayMs) {
        this.taskName = taskName;
        this.executeTime = System.currentTimeMillis() + delayMs;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        // 返回剩余延遲時(shí)間
        long remainingDelay = executeTime - System.currentTimeMillis();
        return unit.convert(remainingDelay, TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed other) {
        // 按執(zhí)行時(shí)間排序（早到期者優(yōu)先）
        return Long.compare(this.executeTime, ((DelayedTask) other).executeTime);
    }

    public void execute() {
        System.out.println("Executing task: " + taskName + " at " + new Date(executeTime));
    }
}

public class DelayQueueScheduler {
    private static final DelayQueue<DelayedTask> queue = new DelayQueue<>();

    public static void main(String[] args) throws InterruptedException {
        // 提交延遲任務(wù)
        queue.put(new DelayedTask("Task 1", 3000)); // 3s 后執(zhí)行
        queue.put(new DelayedTask("Task 2", 1000)); // 1s 后執(zhí)行
        queue.put(new DelayedTask("Task 3", 5000)); // 5s 后執(zhí)行

        // 啟動消費(fèi)者線程處理任務(wù)
        while (!queue.isEmpty()) {
            DelayedTask task = queue.take(); // 阻塞直到有任務(wù)到期
            task.execute();
        }
    }
}

import redis.clients.jedis.Jedis;
import utils.JedisUtils;
import java.time.Instant;
import java.util.Set;

public class DelayQueueExample {
    // zset key
    private static final String _KEY = "myTaskQueue";
    
    public static void main(String[] args) throws InterruptedException {
        Jedis jedis = JedisUtils.getJedis();
        // 30s 后執(zhí)行
        long delayTime = Instant.now().plusSeconds(30).getEpochSecond();
        jedis.zadd(_KEY, delayTime, "order_1");
        // 繼續(xù)添加測試數(shù)據(jù)
        jedis.zadd(_KEY, Instant.now().plusSeconds(2).getEpochSecond(), "order_2");
        jedis.zadd(_KEY, Instant.now().plusSeconds(2).getEpochSecond(), "order_3");
        jedis.zadd(_KEY, Instant.now().plusSeconds(7).getEpochSecond(), "order_4");
        jedis.zadd(_KEY, Instant.now().plusSeconds(10).getEpochSecond(), "order_5");
        // 開啟定時(shí)任務(wù)隊(duì)列
        doDelayQueue(jedis);
    }

    /**
     * 定時(shí)任務(wù)隊(duì)列消費(fèi)
     * @param jedis Redis 客戶端
     */
    public static void doDelayQueue(Jedis jedis) throws InterruptedException {
        while (true) {
            // 當(dāng)前時(shí)間
            Instant nowInstant = Instant.now();
            long lastSecond = nowInstant.plusSeconds(-1).getEpochSecond(); // 上一秒時(shí)間
            long nowSecond = nowInstant.getEpochSecond();
            // 查詢當(dāng)前時(shí)間的所有任務(wù)
            Set<String> data = jedis.zrangeByScore(_KEY, lastSecond, nowSecond);
            for (String item : data) {
                // 消費(fèi)任務(wù)
                System.out.println("消費(fèi)：" + item);
            }
            // 刪除已經(jīng)執(zhí)行的任務(wù)
            jedis.zremrangeByScore(_KEY, lastSecond, nowSecond);
            Thread.sleep(1000); // 每秒查詢一次
        }
    }
}

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPubSub;
import utils.JedisUtils;

public class TaskExample {
    public static final String _TOPIC = "__keyevent@0__:expired"; // 訂閱頻道名稱
    public static void main(String[] args) {
        Jedis jedis = JedisUtils.getJedis();
        // 執(zhí)行定時(shí)任務(wù)
        doTask(jedis);
    }

    /**
     * 訂閱過期消息，執(zhí)行定時(shí)任務(wù)
     * @param jedis Redis 客戶端
     */
    public static void doTask(Jedis jedis) {
        // 訂閱過期消息
        jedis.psubscribe(new JedisPubSub() {
            @Override
            public void onPMessage(String pattern, String channel, String message) {
                // 接收到消息，執(zhí)行定時(shí)任務(wù)
                System.out.println("收到消息：" + message);
            }
        }, _TOPIC);
    }
}