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 个核心组件：

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

3.2 集成步骤

1. 引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

2. 配置 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 采用“调度中心 + 执行器”的分布式架构：

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

2.2 核心特性

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

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 更侧重分布式场景的易用性和可视化管理，简化了集群部署和任务监控的复杂度。