java常用的定时任务框架及相关代码应用示例_Java

在java中，实现定时任务的框架和工具较多，以下是常用的定时任务框架及代码示例：

一、jdk自带定时任务（基础）

1.timer和timertask（简单但功能有限）

timer 是jdk早期提供的定时任务工具，通过单线程执行任务，存在任务阻塞风险，适用于简单场景。

import java.util.timer;
import java.util.timertask;

public class timerexample {
    public static void main(string[] args) {
        timer timer = new timer();
        
        // 任务：延迟1秒后执行，之后每隔2秒执行一次
        timertask task = new timertask() {
            @override
            public void run() {
                system.out.println("timertask执行：" + system.currenttimemillis());
            }
        };
        
        // schedule(任务, 延迟时间(毫秒), 间隔时间(毫秒))
        timer.schedule(task, 1000, 2000);
    }
}

2.scheduledexecutorservice（推荐，线程池支持）

jdk 5+ 引入的线程池定时任务，基于线程池实现，避免单线程阻塞问题，功能更完善。

import java.util.concurrent.executors;
import java.util.concurrent.scheduledexecutorservice;
import java.util.concurrent.timeunit;

public class scheduledexecutorexample {
    public static void main(string[] args) {
        // 创建定时任务线程池（核心线程数为1）
        scheduledexecutorservice executor = executors.newscheduledthreadpool(1);
        
        // 任务：延迟1秒后执行，之后每隔2秒执行一次
        runnable task = () -> system.out.println("scheduledexecutor执行：" + system.currenttimemillis());
        
        // scheduleatfixedrate(任务, 初始延迟, 间隔时间, 时间单位)
        executor.scheduleatfixedrate(task, 1, 2, timeunit.seconds);
    }
}

二、spring框架内置定时任务

spring提供了声明式定时任务支持，通过注解简化配置，依赖spring上下文。

1. 基于@scheduled注解（常用）

需在配置类中开启定时任务支持（@enablescheduling）。

import org.springframework.scheduling.annotation.enablescheduling;
import org.springframework.scheduling.annotation.scheduled;
import org.springframework.stereotype.component;

// 开启定时任务
@enablescheduling
@component
public class springscheduledexample {

    // 固定延迟执行：上一次任务结束后间隔2秒执行
    @scheduled(fixeddelay = 2000)
    public void fixeddelaytask() {
        system.out.println("fixeddelay任务执行：" + system.currenttimemillis());
    }

    // 固定频率执行：每隔2秒执行（无论上一次是否结束）
    @scheduled(fixedrate = 2000)
    public void fixedratetask() {
        system.out.println("fixedrate任务执行：" + system.currenttimemillis());
    }

    // cron表达式：每天12:00执行（支持复杂时间配置）
    @scheduled(cron = "0 0 12 * * ?")
    public void crontask() {
        system.out.println("cron任务执行：" + system.currenttimemillis());
    }
}

cron表达式说明：

格式为 秒分时日月周 [年]，例如：

0 0/5 * * * ?：每5分钟执行一次
0 30 10 ? * mon-fri：每周一至周五10:30执行

三、quartz（强大的企业级框架）

quartz是功能全面的定时任务框架，支持分布式、任务持久化、复杂调度策略等，适用于大型应用。

1. 核心依赖（maven）

<dependency>
    <groupid>org.quartz-scheduler</groupid>
    <artifactid>quartz</artifactid>
    <version>2.3.2</version>
</dependency>

2. 代码示例

import org.quartz.*;
import org.quartz.impl.stdschedulerfactory;

// 定义任务
class myjob implements job {
    @override
    public void execute(jobexecutioncontext context) throws jobexecutionexception {
        system.out.println("quartz任务执行：" + system.currenttimemillis());
    }
}

public class quartzexample {
    public static void main(string[] args) throws schedulerexception {
        // 1. 创建调度器
        scheduler scheduler = stdschedulerfactory.getdefaultscheduler();

        // 2. 创建任务详情
        jobdetail job = jobbuilder.newjob(myjob.class)
                .withidentity("job1", "group1") // 任务id和组
                .build();

        // 3. 创建触发器（cron表达式：每隔2秒执行）
        trigger trigger = triggerbuilder.newtrigger()
                .withidentity("trigger1", "group1")
                .withschedule(cronschedulebuilder.cronschedule("0/2 * * * * ?"))
                .build();

        // 4. 关联任务和触发器，启动调度器
        scheduler.schedulejob(job, trigger);
        scheduler.start();
    }
}

3 springboot 集成的spring boot starter quartz的应用

3.1 核心概念

在使用前需了解 quartz 的 3 个核心组件：

job：具体执行的任务逻辑（实现 org.quartz.job 接口，重写 execute 方法）。
trigger：触发条件（何时执行、执行频率等），支持 simpletrigger（简单重复）和 crontrigger（cron 表达式）。
scheduler：调度器，负责协调 job 和 trigger 的关联，是 quartz 的核心入口。

3.2 集成步骤

引入依赖

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-quartz</artifactid>
</dependency>

配置 quartz
spring boot 提供自动配置，可通过 application.yml 自定义 quartz 行为，核心配置如下：

spring:
  quartz:
    # 任务存储方式：memory（内存，默认，非集群）、jdbc（持久化，支持集群）
    job-store-type: jdbc
    # 集群配置（仅 job-store-type: jdbc 时生效）
    properties:
      org:
        quartz:
          scheduler:
            instancename: myscheduler  # 调度器实例名
            instanceid: auto  # 实例id自动生成（集群中唯一）
          jobstore:
            class: org.quartz.impl.jdbcjobstore.jobstoretx  # 事务型存储
            driverdelegateclass: org.quartz.impl.jdbcjobstore.stdjdbcdelegate  # 数据库适配器（根据数据库选择）
            tableprefix: qrtz_  # 表前缀（quartz 自带表结构）
            isclustered: true  # 开启集群
            clustercheckininterval: 10000  # 集群节点心跳间隔（ms）
          threadpool:
            class: org.quartz.simpl.simplethreadpool  # 线程池实现
            threadcount: 10  # 线程数
            threadpriority: 5  # 线程优先级（1-10）

3、实战示例

定义 job 任务

import org.quartz.job;
import org.quartz.jobexecutioncontext;
import org.quartz.jobexecutionexception;
import org.springframework.stereotype.component;

@component
public class myquartzjob implements job {
    @override
    public void execute(jobexecutioncontext context) throws jobexecutionexception {
        // 任务逻辑：如打印日志、调用服务等
        system.out.println("quartz 任务执行：" + system.currenttimemillis());
        
        // 从上下文获取参数（可选）
        string param = (string) context.getjobdetail().getjobdatamap().get("param");
        system.out.println("接收参数：" + param);
    }
}

配置 jobdetail 和 trigger

import org.quartz.*;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;

@configuration
public class quartzconfig {

    // 1. 定义 jobdetail（任务详情）
    @bean
    public jobdetail myjobdetail() {
        // 绑定任务类，并设置持久化（即使没有trigger关联也不删除）
        return jobbuilder.newjob(myquartzjob.class)
                .withidentity("myjob", "myjobgroup")  // 任务唯一标识（名称+组名）
                .usingjobdata("param", "hello quartz")  // 传递参数
                .storedurably()  // 持久化
                .build();
    }

    // 2. 定义 trigger（触发器）
    @bean
    public trigger mytrigger() {
        // crontrigger：基于cron表达式（此处为每5秒执行一次）
        cronschedulebuilder cronschedule = cronschedulebuilder.cronschedule("0/5 * * * * ?");
        
        return triggerbuilder.newtrigger()
                .forjob(myjobdetail())  // 关联jobdetail
                .withidentity("mytrigger", "mytriggergroup")  // 触发器唯一标识
                .withschedule(cronschedule)  // 绑定调度策略
                .build();
    }
}

启动测试

启动 spring boot 应用，控制台会每隔5秒打印任务执行日志，说明集成成功。

动态操作任务（增删改查）

实际开发中常需动态管理任务（如通过接口添加/暂停任务），可注入 scheduler 进行操作：

import org.quartz.*;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.web.bind.annotation.*;

@restcontroller
@requestmapping("/quartz")
public class quartzcontroller {

    @autowired
    private scheduler scheduler;

    // 新增任务
    @postmapping("/add")
    public string addjob() throws schedulerexception {
        // 1. 构建jobdetail
        jobdetail jobdetail = jobbuilder.newjob(myquartzjob.class)
                .withidentity("dynamicjob", "dynamicgroup")
                .usingjobdata("param", "动态任务")
                .storedurably()
                .build();

        // 2. 构建trigger（每10秒执行一次）
        trigger trigger = triggerbuilder.newtrigger()
                .forjob(jobdetail)
                .withidentity("dynamictrigger", "dynamicgroup")
                .withschedule(cronschedulebuilder.cronschedule("0/10 * * * * ?"))
                .build();

        // 3. 注册到调度器
        scheduler.schedulejob(jobdetail, trigger);
        return "任务添加成功";
    }

    // 暂停任务
    @postmapping("/pause/{jobname}/{jobgroup}")
    public string pausejob(@pathvariable string jobname, @pathvariable string jobgroup) throws schedulerexception {
        jobkey jobkey = jobkey.jobkey(jobname, jobgroup);
        scheduler.pausejob(jobkey);
        return "任务暂停成功";
    }

    // 恢复任务
    @postmapping("/resume/{jobname}/{jobgroup}")
    public string resumejob(@pathvariable string jobname, @pathvariable string jobgroup) throws schedulerexception {
        jobkey jobkey = jobkey.jobkey(jobname, jobgroup);
        scheduler.resumejob(jobkey);
        return "任务恢复成功";
    }

    // 删除任务
    @postmapping("/delete/{jobname}/{jobgroup}")
    public string deletejob(@pathvariable string jobname, @pathvariable string jobgroup) throws schedulerexception {
        jobkey jobkey = jobkey.jobkey(jobname, jobgroup);
        // 先删除触发器，再删除任务
        scheduler.pausetrigger(triggerkey.triggerkey(jobname, jobgroup));
        scheduler.unschedulejob(triggerkey.triggerkey(jobname, jobgroup));
        scheduler.deletejob(jobkey);
        return "任务删除成功";
    }
}

通过 spring-boot-starter-quartz，spring boot 开发者可快速集成强大的定时任务能力，满足从简单定时到分布式复杂调度的各种需求。

四、分布式定时任务框架（集群环境）

在分布式系统中，需避免任务重复执行，常用框架：

1. elastic-job（当当网开源，基于zookeeper）

// 定义任务
public class myelasticjob implements simplejob {
    @override
    public void execute(shardingcontext context) {
        system.out.println("分片" + context.getshardingitem() + "执行任务");
    }
}

// 配置任务（spring环境）
@configuration
public class elasticjobconfig {
    @bean
    public simplejob myjob() {
        return new myelasticjob();
    }

    @bean(initmethod = "init")
    public jobscheduler jobscheduler(simplejob myjob, zookeeperregistrycenter regcenter) {
        return jobschedulerbuilder.newbuilder(myjob)
                .registrycenter(regcenter)
                .cron("0/2 * * * * ?") // 定时策略
                .shardingtotalcount(2) // 分片数
                .build();
    }
}

2. xxl-job（大众点评开源，轻量级分布式任务）

通过admin控制台配置任务，代码只需实现执行逻辑：

@xxljob("xxljobdemo")
public void xxljobdemo() throws exception {
    system.out.println("xxl-job任务执行：" + system.currenttimemillis());
}

2.1 核心架构

xxl-job 采用“调度中心 + 执行器”的分布式架构：

调度中心：集中管理任务调度，负责任务配置、触发调度、监控执行结果等（基于 spring boot 开发，可独立部署）。
执行器：部署在业务服务中，负责接收调度中心的任务指令并执行具体逻辑（通过 http 与调度中心通信）。

2.2 核心特性

分布式调度：支持集群部署，调度中心通过负载均衡策略（如轮询、一致性哈希）向执行器分发任务，避免单点故障。
丰富的任务类型：支持 cron 表达式定时任务、固定频率任务、失败重试、任务依赖等。
可视化管理：提供 web 控制台，可在线配置任务、启停任务、查看执行日志、监控任务状态。
弹性扩容：执行器可动态增减节点，调度中心自动感知并调整负载。
失败处理：支持任务失败重试、失败告警（邮件、短信等）。
日志追踪：执行日志集中存储，支持在线查看和检索。

2.3部署调度中心

从 github 下载源码，初始化调度中心数据库（脚本 doc/db/tables_xxl_job.sql）。
配置调度中心 application.properties（数据库连接、端口等），启动 xxl-job-admin 模块。

2.4 执行器集成

（1）引入依赖

<dependency>
    <groupid>com.xuxueli</groupid>
    <artifactid>xxl-job-core</artifactid>
    <version>2.4.0</version> <!-- 版本与调度中心一致 -->
</dependency>

（2）配置执行器

xxl:
  job:
    admin:
      addresses: http://127.0.0.1:8080/xxl-job-admin  # 调度中心地址
    executor:
      appname: my-executor  # 执行器名称（唯一）
      port: 9999  # 执行器端口（默认9999，可选）
      logpath: /data/xxl-job/logs  # 日志路径

（3）注册执行器并定义任务

// 配置执行器客户端
@configuration
public class xxljobconfig {
    @value("${xxl.job.admin.addresses}")
    private string adminaddresses;
    @value("${xxl.job.executor.appname}")
    private string appname;

    @bean
    public xxljobspringexecutor xxljobexecutor() {
        xxljobspringexecutor executor = new xxljobspringexecutor();
        executor.setadminaddresses(adminaddresses);
        executor.setappname(appname);
        return executor;
    }
}

// 定义任务（@xxljob注解指定任务标识）
@component
public class myxxljob {
    @xxljob("demojobhandler") // 任务标识，需与调度中心配置一致
    public void execute() throws exception {
        string param = xxljobhelper.getjobparam(); // 获取任务参数
        xxljobhelper.log("任务执行：" + param); // 日志记录
        // 业务逻辑...
    }
}

2.5 调度中心配置任务

登录调度中心 web 控制台（默认地址 http://localhost:8080/xxl-job-admin，账号 admin/123456）。
新增执行器（配置执行器名称 my-executor）。
新增任务：选择执行器，填写任务标识 demojobhandler、cron 表达式（如 0/5 * * * * ?），启动任务。

适用场景

分布式定时任务（如定时数据同步、报表生成）。
需要统一管理和监控的任务调度场景。
对任务失败重试、告警有需求的业务。

相比 quartz，xxl-job 更侧重分布式场景的易用性和可视化管理，简化了集群部署和任务监控的复杂度。

总结

到此这篇关于java常用的定时任务框架及相关代码应用的文章就介绍到这了,更多相关java定时任务框架及应用内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

java常用的定时任务框架及相关代码应用示例

2025年11月03日 • Java •我要评论