Java中实现定时任务执行的几种常见方式总结_Java

一、概述

关于在java项目中实现定时任务执行的几种方式总结如下：

单进程实现定时任务主要有以下几种方式：

1. timer 和 timertask（jdk 原生）

2. scheduledexecutorservice（jdk 1.5+，推荐）

3. spring task（spring 框架支持）

4. quartz（企业级任务调度框架）

5. delayqueue 阻塞队列

分布式定时任务

1、使用redis来实现定时任务

2、使用xxl-job实现定时任务

二、详情

1. timer 和 timertask（jdk 原生）

java中的timer类是一个定时调度器，用于在指定的时间点执行任务。timer 类用于实现定时任务，最大的好处就是他的实现非常简单，特别的轻量级，因为它是java内置的，所以只需要简单调用就行了。

public class mytimertask {

    public static void main(string[] args) {
        // 定义一个任务
        timertask timertask = new timertask() {
            @override
            public void run() {
                system.out.println("run timertask：" + new date());
            }
        };
        // 计时器
        timer timer = new timer();
        // 添加执行任务（延迟 1s 执行，每 3s 执行一次）
        timer.schedule(timertask, 1000, 3000);
    }
}

优点	缺点
简单易用，适合单线程任务调度。基于绝对时间（date）执行任务。	timer内部是单线程执行任务的，如果某个任务执行时间较长，会影响后续任务的执行。如果任务抛出未捕获异常，将导致整个 timer 线程终止，影响其他任务的执行。 timer 无法提供高精度的定时任务。因为系统调度和任务执行时间的不确定性，可能导致任务执行的时间不准确。虽然可以使用 cancel 方法取消任务，但这仅仅是将任务标记为取消状态，仍然会在任务队列中占用位置，无法释放资源。这可能导致内存泄漏。当有大量任务时，timer 的性能可能受到影响，因为它在每次扫描任务队列时都要进行时间比较。 timer执行任务完全基于jvm内存，一旦应用重启，那么队列中的任务就都没有了

优点

缺点

简单易用，适合单线程任务调度。
基于绝对时间（date）执行任务。

timer内部是单线程执行任务的，如果某个任务执行时间较长，会影响后续任务的执行。
如果任务抛出未捕获异常，将导致整个 timer 线程终止，影响其他任务的执行。
timer 无法提供高精度的定时任务。因为系统调度和任务执行时间的不确定性，可能导致任务执行的时间不准确。
虽然可以使用 cancel 方法取消任务，但这仅仅是将任务标记为取消状态，仍然会在任务队列中占用位置，无法释放资源。这可能导致内存泄漏。
当有大量任务时，timer 的性能可能受到影响，因为它在每次扫描任务队列时都要进行时间比较。
timer执行任务完全基于jvm内存，一旦应用重启，那么队列中的任务就都没有了

2. scheduledexecutorservice（jdk 1.5+，推荐）

scheduledexecutorservice基于线程池（threadpoolexecutor），支持多任务并发执行。相比 timer，更稳定、更灵活。

scheduledexecutorservice scheduler = executors.newscheduledthreadpool(2);

// 延迟 1s 后执行
scheduler.schedule(() -> {
    system.out.println("task executed once at: " + new date());
}, 1, timeunit.seconds);

// 延迟 1s 后执行，之后每 2s 执行一次
scheduler.scheduleatfixedrate(() -> {
    system.out.println("fixed-rate task executed at: " + new date());
}, 1, 2, timeunit.seconds);

优点	缺点
是 jdk 1.5 之后自带的 api，因此使用起来也比较方便执行任务时使用线程池管理，不会造成任务间的相互影响支持 scheduleatfixedrate（固定频率）和 schedulewithfixeddelay（固定间隔）。	需要配置线程池如果任务抛出异常，后续任务会被取消！需在任务内捕获异常。

3. spring task（spring 框架支持）

适合 spring/spring boot 项目，基于 scheduledexecutorservice，提供注解式任务调度。

@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("定时任务...");
    }
}

优点	缺点
注解驱动，开发简单。支持 cron 表达式（如 0 0 12 * * ? 表示每天中午 12 点执行）。	只适合 spring/spring boot 项目

4. quartz（企业级任务调度框架）

quartz是opensymphony开源组织在job scheduling领域的一个java实现的开源项目。

// 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 执行一次
        .repeatforever())
    .build();

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

优点	缺点
支持数据库持久化，重启后可恢复调度支持动态调整任务（如暂停、恢复、修改执行时间）	分布式需要使用数据库

5. delayqueue 阻塞队列

delayqueue是一个带有延迟时间的无界阻塞队列，它的元素必须实现delayed接口。当从delayqueue中取出一个元素时，如果其延迟时间还未到达，则会阻塞等待，直到延迟时间到达。因此，我们可以通过将任务封装成实现delayed接口的元素，将其放入delayqueue中，再使用一个线程不断地从delayqueue中取出元素并执行任务，从而实现定时任务的调度。

import java.util.concurrent.delayed;
import java.util.concurrent.timeunit;

public class delayedtask implements delayed {
    private final string taskname;
    private final long executetime; // 执行时间（毫秒时间戳）

    public delayedtask(string taskname, long delayms) {
        this.taskname = taskname;
        this.executetime = system.currenttimemillis() + delayms;
    }

    @override
    public long getdelay(timeunit unit) {
        // 返回剩余延迟时间
        long remainingdelay = executetime - system.currenttimemillis();
        return unit.convert(remainingdelay, timeunit.milliseconds);
    }

    @override
    public int compareto(delayed other) {
        // 按执行时间排序（早到期者优先）
        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 {
        // 提交延迟任务
        queue.put(new delayedtask("task 1", 3000)); // 3s 后执行
        queue.put(new delayedtask("task 2", 1000)); // 1s 后执行
        queue.put(new delayedtask("task 3", 5000)); // 5s 后执行

        // 启动消费者线程处理任务
        while (!queue.isempty()) {
            delayedtask task = queue.take(); // 阻塞直到有任务到期
            task.execute();
        }
    }
}

优点	缺点
精确延迟、无第三方依赖	只能单进程内使用

6、使用 redis 实现延迟任务

使用 redis 实现延迟任务的方法大体可分为两类：通过 zset 的方式和键空间通知的方式。

① zset 实现方式

通过 zset 实现定时任务的思路是，将定时任务存放到 zset 集合中，并且将过期时间存储到 zset 的 score 字段中，然后通过一个无线循环来判断当前时间内是否有需要执行的定时任务，如果有则进行执行，具体实现代码如下：

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 后执行
        long delaytime = instant.now().plusseconds(30).getepochsecond();
        jedis.zadd(_key, delaytime, "order_1");
        // 继续添加测试数据
        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");
        // 开启定时任务队列
        dodelayqueue(jedis);
    }

    /**
     * 定时任务队列消费
     * @param jedis redis 客户端
     */
    public static void dodelayqueue(jedis jedis) throws interruptedexception {
        while (true) {
            // 当前时间
            instant nowinstant = instant.now();
            long lastsecond = nowinstant.plusseconds(-1).getepochsecond(); // 上一秒时间
            long nowsecond = nowinstant.getepochsecond();
            // 查询当前时间的所有任务
            set<string> data = jedis.zrangebyscore(_key, lastsecond, nowsecond);
            for (string item : data) {
                // 消费任务
                system.out.println("消费：" + item);
            }
            // 删除已经执行的任务
            jedis.zremrangebyscore(_key, lastsecond, nowsecond);
            thread.sleep(1000); // 每秒查询一次
        }
    }
}

② 键空间通知

我们可以通过 redis 的键空间通知来实现定时任务，它的实现思路是给所有的定时任务设置一个过期时间，等到了过期之后，我们通过订阅过期消息就能感知到定时任务需要被执行了，此时我们执行定时任务即可。

默认情况下 redis 是不开启键空间通知的，需要我们通过 config set notify-keyspace-events ex 的命令手动开启，开启之后定时任务的代码如下：

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();
        // 执行定时任务
        dotask(jedis);
    }

    /**
     * 订阅过期消息，执行定时任务
     * @param jedis redis 客户端
     */
    public static void dotask(jedis jedis) {
        // 订阅过期消息
        jedis.psubscribe(new jedispubsub() {
            @override
            public void onpmessage(string pattern, string channel, string message) {
                // 接收到消息，执行定时任务
                system.out.println("收到消息：" + message);
            }
        }, _topic);
    }
}