Java实现定时任务调度案例

wen java案例 2026-08-04 183

本文目录导读：

Java实现定时任务调度案例

使用 ScheduledExecutorService（推荐）
使用 Timer 和 TimerTask
使用 Quartz 框架
使用 Spring 的 @Scheduled 注解（Spring Boot）
生产环境定时任务管理器
常用CRON表达式示例
选择建议

我来提供一个完整的Java定时任务调度案例,包含多种实现方式：

使用 ScheduledExecutorService（推荐）

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledExecutorExample {
    private static final DateTimeFormatter FORMATTER = 
        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    public static void main(String[] args) {
        // 创建调度线程池
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
        // 1. 延迟5秒后执行一次
        scheduler.schedule(() -> {
            System.out.println("[" + getCurrentTime() + "] 一次性任务执行");
        }, 5, TimeUnit.SECONDS);
        // 2. 固定频率执行（每3秒执行一次）
        scheduler.scheduleAtFixedRate(() -> {
            System.out.println("[" + getCurrentTime() + "] 固定频率任务执行");
        }, 0, 3, TimeUnit.SECONDS);
        // 3. 固定延迟执行（上次执行完后2秒再执行）
        scheduler.scheduleWithFixedDelay(() -> {
            try {
                Thread.sleep(2000); // 模拟任务执行耗时
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("[" + getCurrentTime() + "] 固定延迟任务执行");
        }, 0, 2, TimeUnit.SECONDS);
        // 设置定时关闭（演示用，实际项目中根据需要）
        scheduler.schedule(() -> {
            System.out.println("调度器关闭");
            scheduler.shutdown();
        }, 20, TimeUnit.SECONDS);
    }
    private static String getCurrentTime() {
        return LocalDateTime.now().format(FORMATTER);
    }
}

使用 Timer 和 TimerTask

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class TimerExample {
    public static void main(String[] args) throws InterruptedException {
        Timer timer = new Timer("MyTimer");
        // 1. 立即执行，然后每2秒执行一次
        timer.schedule(new SimpleTask("任务A"), 0, 2000);
        // 2. 延迟3秒执行一次
        timer.schedule(new SimpleTask("任务B"), 3000);
        // 3. 指定时间执行
        Date scheduledTime = new Date(System.currentTimeMillis() + 5000);
        timer.schedule(new SimpleTask("任务C"), scheduledTime);
        // 4. 演示取消任务
        TimerTask cancelTask = new SimpleTask("将被取消的任务");
        timer.schedule(cancelTask, 1000, 1000);
        // 5秒后取消指定任务
        Thread.sleep(5000);
        cancelTask.cancel();
        System.out.println("已取消任务");
        // 10秒后取消所有任务
        Thread.sleep(5000);
        timer.cancel();
        System.out.println("所有任务已取消");
    }
    static class SimpleTask extends TimerTask {
        private final String taskName;
        public SimpleTask(String taskName) {
            this.taskName = taskName;
        }
        @Override
        public void run() {
            System.out.println("[" + new Date() + "] " + taskName + " 执行时间：" + 
                new java.text.SimpleDateFormat("HH:mm:ss").format(new Date()));
        }
    }
}

使用 Quartz 框架

1 Maven依赖

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
</dependency>

2 完整的Quartz实现

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class QuartzExample {
    private static final DateTimeFormatter FORMATTER = 
        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    // 定义一个Job类
    public static class MyJob implements Job {
        @Override
        public void execute(JobExecutionContext context) throws JobExecutionException {
            JobDataMap dataMap = context.getJobDetail().getJobDataMap();
            String jobName = dataMap.getString("jobName");
            System.out.println("[" + LocalDateTime.now().format(FORMATTER) + 
                "] 任务[" + jobName + "]执行，线程：" + Thread.currentThread().getName());
        }
    }
    public static void main(String[] args) {
        try {
            // 创建调度器
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
            // 1. 简单触发器 - 每3秒执行一次
            JobDetail simpleJob = JobBuilder.newJob(MyJob.class)
                    .withIdentity("simpleJob", "group1")
                    .usingJobData("jobName", "简单任务")
                    .build();
            SimpleTrigger simpleTrigger = TriggerBuilder.newTrigger()
                    .withIdentity("simpleTrigger", "group1")
                    .startNow()
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                            .withIntervalInSeconds(3)
                            .repeatForever())
                    .build();
            scheduler.scheduleJob(simpleJob, simpleTrigger);
            // 2. Cron触发器 - 每天的特定时间执行
            JobDetail cronJob = JobBuilder.newJob(MyJob.class)
                    .withIdentity("cronJob", "group2")
                    .usingJobData("jobName", "CRON任务")
                    .build();
            // Cron表达式：秒 分 时 日 月 周
            // 这里设置每30秒执行一次
            CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                    .withIdentity("cronTrigger", "group2")
                    .withSchedule(CronScheduleBuilder.cronSchedule("0/30 * * * * ?"))
                    .build();
            scheduler.scheduleJob(cronJob, cronTrigger);
            // 启动调度器
            scheduler.start();
            // 演示5秒后暂停某个Job
            Thread.sleep(5000);
            System.out.println("暂停simpleJob");
            scheduler.pauseJob(JobKey.jobKey("simpleJob", "group1"));
            // 再过3秒恢复
            Thread.sleep(3000);
            System.out.println("恢复simpleJob");
            scheduler.resumeJob(JobKey.jobKey("simpleJob", "group1"));
            // 运行15秒后关闭
            Thread.sleep(15000);
            scheduler.shutdown();
            System.out.println("调度器已关闭");
        } catch (SchedulerException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

使用 Spring 的 @Scheduled 注解（Spring Boot）

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@SpringBootApplication
@EnableScheduling // 启用定时任务
public class SpringBootSchedulerApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootSchedulerApplication.class, args);
    }
}
@Component
class ScheduledTasks {
    private final org.slf4j.Logger logger = 
        org.slf4j.LoggerFactory.getLogger(ScheduledTasks.class);
    // 固定延迟 - 上一次执行完3秒后执行
    @Scheduled(fixedDelay = 3000)
    public void fixedDelayTask() {
        logger.info("固定延迟任务执行: {}", System.currentTimeMillis());
        try {
            Thread.sleep(1000); // 模拟任务耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    // 固定频率 - 每2秒执行一次（并行执行）
    @Scheduled(fixedRate = 2000)
    public void fixedRateTask() {
        logger.info("固定频率任务执行: {}", System.currentTimeMillis());
    }
    // 初始延迟5秒后，每4秒执行一次
    @Scheduled(initialDelay = 5000, fixedRate = 4000)
    public void initialDelayTask() {
        logger.info("带初始延迟的任务执行: {}", System.currentTimeMillis());
    }
    // Cron表达式任务 - 每天中午12点执行
    @Scheduled(cron = "0 0 12 * * ?")
    public void cronTask() {
        logger.info("每天中午12点执行的任务");
    }
    // Cron表达式 - 每小时的15分、30分执行
    @Scheduled(cron = "0 15,30 * * * ?")
    public void multipleTimesTask() {
        logger.info("每小时15分和30分执行的任务");
    }
    // Cron表达式 - 工作日早上9点执行
    @Scheduled(cron = "0 0 9 ? * MON-FRI")
    public void workdayTask() {
        logger.info("工作日早上9点执行的任务");
    }
    // Cron表达式 - 每月1号零点执行
    @Scheduled(cron = "0 0 0 1 * ?")
    public void monthlyTask() {
        logger.info("每月1号执行的任务");
    }
}

生产环境定时任务管理器

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * 生产环境定时任务管理器
 */
public class TaskSchedulerManager {
    // 调度线程池
    private final ScheduledExecutorService scheduler;
    // 监控线程池
    private final ConcurrentHashMap<String, TaskInfo> taskRegistry = new ConcurrentHashMap<>();
    // 任务执行计数器
    private final AtomicInteger taskCounter = new AtomicInteger(0);
    private static final DateTimeFormatter FORMATTER = 
        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    public TaskSchedulerManager() {
        // 创建固定大小的调度线程池
        this.scheduler = Executors.newScheduledThreadPool(4, r -> {
            Thread thread = new Thread(r, "schedule-worker");
            thread.setUncaughtExceptionHandler((t, e) -> 
                System.out.println("[" + getCurrentTime() + "] 线程异常: " + e.getMessage()));
            return thread;
        });
    }
    /**
     * 任务信息
     */
    public static class TaskInfo {
        private final String taskId;
        private final String taskName;
        private final ScheduledFuture<?> future;
        private final Long executeCount;
        private Throwable lastError;
        public TaskInfo(String taskId, String taskName, ScheduledFuture<?> future) {
            this.taskId = taskId;
            this.taskName = taskName;
            this.future = future;
            this.executeCount = 0L;
        }
        public String getTaskId() { return taskId; }
        public String getTaskName() { return taskName; }
        public ScheduledFuture<?> getFuture() { return future; }
        public Long getExecuteCount() { return executeCount; }
        public boolean isCancelled() {
            return future.isCancelled();
        }
        public boolean isDone() {
            return future.isDone();
        }
    }
    /**
     * 注册固定频率任务
     */
    public TaskInfo scheduleAtFixedRate(String taskId, String taskName, 
                                        Runnable task, long initialDelay, long period) {
        try {
            ScheduledFuture<?> future = scheduler.scheduleAtFixedRate(() -> {
                try {
                    taskCounter.incrementAndGet();
                    System.out.println("[" + getCurrentTime() + "] " + taskName + " 开始执行");
                    task.run();
                    System.out.println("[" + getCurrentTime() + "] " + taskName + " 执行完成");
                } catch (Exception e) {
                    System.err.println("[" + getCurrentTime() + "] " + taskName + " 执行异常: " + e.getMessage());
                }
            }, initialDelay, period, TimeUnit.SECONDS);
            TaskInfo taskInfo = new TaskInfo(taskId, taskName, future);
            taskRegistry.put(taskId, taskInfo);
            System.out.println("[" + getCurrentTime() + "] 注册固定频率任务: " + taskName);
            return taskInfo;
        } catch (Exception e) {
            System.err.println("注册任务失败: " + e.getMessage());
            throw new RuntimeException("任务注册失败", e);
        }
    }
    /**
     * 注册一次性延迟任务
     */
    public TaskInfo scheduleOneTime(String taskId, String taskName, 
                                     Runnable task, long delay) {
        ScheduledFuture<?> future = scheduler.schedule(() -> {
            try {
                taskCounter.incrementAndGet();
                System.out.println("[" + getCurrentTime() + "] " + taskName + " 开始执行（一次性）");
                task.run();
                System.out.println("[" + getCurrentTime() + "] " + taskName + " 执行完成（一次性）");
            } catch (Exception e) {
                System.err.println("[" + getCurrentTime() + "] " + taskName + " 执行异常: " + e.getMessage());
            }
        }, delay, TimeUnit.SECONDS);
        TaskInfo taskInfo = new TaskInfo(taskId, taskName, future);
        taskRegistry.put(taskId, taskInfo);
        System.out.println("[" + getCurrentTime() + "] 注册一次性任务: " + taskName);
        return taskInfo;
    }
    /**
     * 取消任务
     */
    public boolean cancelTask(String taskId, boolean mayInterruptIfRunning) {
        TaskInfo taskInfo = taskRegistry.get(taskId);
        if (taskInfo != null && taskInfo.getFuture() != null) {
            boolean cancelled = taskInfo.getFuture().cancel(mayInterruptIfRunning);
            if (cancelled) {
                System.out.println("[" + getCurrentTime() + "] 任务取消成功: " + taskInfo.getTaskName());
                taskRegistry.remove(taskId);
            }
            return cancelled;
        }
        return false;
    }
    /**
     * 获取所有任务状态
     */
    public void printTaskStatus() {
        System.out.println("========== 任务状态 ==========");
        taskRegistry.forEach((taskId, taskInfo) -> {
            System.out.println("任务ID: " + taskId + 
                ", 名称: " + taskInfo.getTaskName() + 
                ", 状态: " + (taskInfo.isCancelled() ? "已取消" : 
                               taskInfo.isDone() ? "已完成" : "运行中"));
        });
        System.out.println("总执行次数: " + taskCounter.get());
        System.out.println("================================");
    }
    /**
     * 关闭调度器
     */
    public void shutdown() {
        System.out.println("[" + getCurrentTime() + "] 开始关闭调度器...");
        scheduler.shutdown();
        try {
            if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                scheduler.shutdownNow();
            }
            System.out.println("[" + getCurrentTime() + "] 调度器已关闭");
        } catch (InterruptedException e) {
            scheduler.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
    private static String getCurrentTime() {
        return LocalDateTime.now().format(FORMATTER);
    }
    // 测试主方法
    public static void main(String[] args) throws InterruptedException {
        TaskSchedulerManager manager = new TaskSchedulerManager();
        // 注册各种任务
        manager.scheduleAtFixedRate("task1", "数据备份任务", () -> {
            System.out.println("备份数据到远程服务器...");
        }, 0, 5);
        manager.scheduleAtFixedRate("task2", "日志清理任务", () -> {
            System.out.println("清理过期日志文件...");
        }, 2, 10);
        manager.scheduleOneTime("task3", "系统维护任务", () -> {
            System.out.println("执行系统维护...");
        }, 8);
        // 模拟运行环境
        Thread.sleep(15000);
        // 查看任务状态
        manager.printTaskStatus();
        // 取消某个任务
        manager.cancelTask("task2", true);
        // 关闭调度器
        Thread.sleep(5000);
        manager.shutdown();
    }
}

常用CRON表达式示例

public class CronExamples {
    /*
     * 常用CRON表达式示例（Quartz格式）：
     * 
     * "0 0 12 * * ?"     - 每天中午12点执行
     * "0 15 10 ? * *"    - 每天10:15执行
     * "0 15 10 * * ?"    - 每天10:15执行
     * "0 0/5 14,18 * * ?" - 每天14点和18点的0分、5分、10分...
     * "0 15 10 ? * MON-FRI" - 周一至周五10:15执行
     * "0 15 10 15 * ?"   - 每月15日10:15执行
     * "0 0 2 1 * ?"      - 每月1日凌晨2点执行
     * "0 0 0 ? * MON"    - 每周一零点执行
     * "0 0 0 1 1 ?"      - 每年1月1日零点执行
     * 
     * 字段含义：
     * 位置1: 秒 (0-59)
     * 位置2: 分 (0-59)
     * 位置3: 时 (0-23)
     * 位置4: 日 (1-31)
     * 位置5: 月 (1-12 或 JAN-DEC)
     * 位置6: 周 (1-7 或 SUN-SAT)
     * 位置7: 年(可选) (1970-2099)
     * 
     * 特殊字符：
     * * : 所有值
     * ? : 不指定值（仅用于日/周）
     * - : 范围
     * , : 列表
     * / : 步长
     */
}