从入门到精通：Java 定时任务全解析，从原生到分布式实战指南​

import lombok.extern.slf4j.Slf4j;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Date;
@Slf4j
public class TimerExample {
    public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask task = new TimerTask() {
            private int count = 0;
            @Override
            public void run() {
                count++;
                log.info("第{}次执行，时间：{}", count, new Date());
                if (count >= 5) { // 执行5次后停止
                    this.cancel();
                    timer.cancel();
                }
            }
        };
        log.info("启动时间：{}", new Date());
        timer.schedule(task, 1000, 5000); // 延迟1秒，每隔5秒执行
    }
}

import lombok.extern.slf4j.Slf4j;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@Slf4j
public class ScheduledExecutorExample {
    public static void main(String[] args) {
        // 创建2个线程的线程池
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
        log.info("启动时间：{}", new Date());
        // 固定延迟任务：任务执行完隔3秒再执行
        Runnable fixedDelayTask = () -> {
            log.info("【固定延迟】执行时间：{}", new Date());
            try { TimeUnit.SECONDS.sleep(2); } // 模拟耗时2秒
            catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        };
        executor.scheduleWithFixedDelay(fixedDelayTask, 1, 3, TimeUnit.SECONDS);
        // 固定速率任务：每隔3秒执行一次
        Runnable fixedRateTask = () -> {
            log.info("【固定速率】执行时间：{}", new Date());
            try { TimeUnit.SECONDS.sleep(2); } // 模拟耗时2秒
            catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        };
        executor.scheduleAtFixedRate(fixedRateTask, 1, 3, TimeUnit.SECONDS);
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
@Slf4j
@Component
public class ScheduledTaskService {
    // 固定延迟：任务完后隔2秒执行
    @Scheduled(fixedDelay = 2000)
    public void fixedDelayTask() {
        log.info("【fixedDelay】时间：{}", LocalDateTime.now());
    }
    // cron表达式：每分钟第0秒执行
    @Scheduled(cron = "0 * * * * ?")
    public void cronTask() {
        log.info("【cron】时间：{}", LocalDateTime.now());
    }
    // 从配置文件取间隔（默认3秒）
    @Scheduled(fixedDelayString = "${task.delay:3000}")
    public void configTask() {
        log.info("【配置任务】时间：{}", LocalDateTime.now());
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
@Configuration
public class TaskExecutorConfig {
    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5); // 核心线程5个
        executor.setMaxPoolSize(10); // 最大线程10个
        executor.setQueueCapacity(20); // 队列容量20
        executor.setThreadNamePrefix("Scheduled-"); // 线程名前缀
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 拒绝策略
        return executor;
    }
}

@Async("taskExecutor")
@Scheduled(cron = "0/5 * * * * ?")
public void asyncTask() {
    log.info("【异步任务】线程：{}，时间：{}", 
             Thread.currentThread().getName(), LocalDateTime.now());
}

@Slf4j
public class SampleJob implements Job {
    @Override
    public void execute(JobExecutionContext context) {
        String param = context.getJobDetail().getJobDataMap().getString("param");
        log.info("【Quartz任务】参数：{}，时间：{}", param, LocalDateTime.now());
    }
}

@Configuration
public class QuartzConfig {
    @Bean
    public JobDetail sampleJobDetail() {
        JobDataMap map = new JobDataMap();
        map.put("param", "Quartz示例任务");
        return JobBuilder.newJob(SampleJob.class)
                .withIdentity("sampleJob", "group1")
                .setJobData(map)
                .storeDurably()
                .build();
    }
    @Bean
    public Trigger sampleTrigger() {
        // 每5秒执行一次
        CronScheduleBuilder cron = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");
        return TriggerBuilder.newTrigger()
                .forJob(sampleJobDetail())
                .withIdentity("sampleTrigger", "group1")
                .withSchedule(cron)
                .build();
    }
}

spring:
  quartz:
    properties:
      org:
        quartz:
          jobStore:
            isClustered: true # 启用集群
            clusterCheckinInterval: 15000 # 节点检查间隔15秒
            class: org.quartz.impl.jdbcjobstore.JobStoreTX # 数据库存储
          scheduler:
            instanceId: AUTO # 自动生成实例ID（集群唯一）

<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
    <version>2.3.0</version>
</dependency>

xxl:
  job:
    admin:
      addresses: http://localhost:8080/xxl-job-admin # 调度中心地址
    executor:
      appname: demo-executor # 执行器名称
      port: 9999 # 端口

@Configuration
public class XxlJobConfig {
    @Bean
    public XxlJobSpringExecutor xxlJobExecutor(@Value("${xxl.job.admin.addresses}") String adminAddresses) {
        XxlJobSpringExecutor executor = new XxlJobSpringExecutor();
        executor.setAdminAddresses(adminAddresses);
        executor.setAppname("demo-executor");
        executor.setPort(9999);
        return executor;
    }
}

@Slf4j
@Component
public class XxlJobHandler {
    // 任务标识：@XxlJob("任务名")
    @XxlJob("simpleJob")
    public void simpleJob() {
        log.info("【XXL-Job】执行时间：{}", LocalDateTime.now());
        // 任务逻辑...
        XxlJobHelper.handleSuccess("执行成功"); // 返回结果
    }
}