java 实现定时任务的方式

1. 使用 java.util.Timer

Timer 是 Java 提供的一个简单定时任务调度工具，适用于简单的单线程定时任务。

java复制

import java.util.Timer;
import java.util.TimerTask;

public class TimerExample {
    public static void main(String[] args) {
        Timer timer = new Timer();

        // 定义一个定时任务
        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                System.out.println("任务执行: " + new java.util.Date());
            }
        };

        // 安排任务在 1秒 后执行，之后每隔 2秒 执行一次
        timer.schedule(task, 1000, 2000);
    }
}

优点：

• 简单易用，适合简单的单线程任务。

缺点：

• 如果任务抛出异常，后续任务不会执行。

• 不支持复杂的调度任务，如基于日历或时间表达式的任务调度。

2. 使用 java.util.concurrent.ScheduledExecutorService

ScheduledExecutorService 是 Java 提供的一个更强大的定时任务调度工具，支持多线程和固定延迟任务调度。

java复制

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledExecutorServiceExample {
    public static void main(String[] args) {
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);

        // 定义一个定时任务
        Runnable task = () -> System.out.println("任务执行: " + new java.util.Date());

        // 安排任务在 1秒 后执行，之后每隔 2秒 执行一次
        scheduler.scheduleAtFixedRate(task, 1, 2, TimeUnit.SECONDS);

        // 安排任务在每次任务执行完成后间隔 2秒 执行
        scheduler.scheduleWithFixedDelay(task, 1, 2, TimeUnit.SECONDS);
    }
}

优点：

• 支持多线程，适合复杂的多线程任务。

• 提供 scheduleAtFixedRate 和 scheduleWithFixedDelay 两种调度方式。

缺点：

• 不支持复杂的调度任务，如基于日历或时间表达式的任务调度。

3. 使用 Spring 的 @Scheduled 注解

Spring 提供了简单的注解式定时任务支持，适用于 Spring 应用程序。

java复制

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTask {

    // 每 5秒 执行一次
    @Scheduled(fixedRate = 5000)
    public void scheduledTask() {
        System.out.println("任务执行: " + new java.util.Date());
    }
}

启用定时任务： 在 Spring Boot 应用程序中，需要在主类或其他配置类上添加 @EnableScheduling 注解：

java复制

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

优点：

• 简单易用，适合 Spring 应用程序。

• 支持多种调度方式，如固定速率、固定延迟、Cron 表达式等。

缺点：

• 依赖 Spring 框架，不适合非 Spring 应用程序。

• 不支持复杂的调度任务，如动态调整任务调度时间。

4. 使用 Quartz 调度框架

Quartz 是一个功能强大的调度框架，支持复杂的调度任务和分布式调度。

Maven 依赖

在 pom.xml 中添加以下依赖：

xml复制

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

代码示例

java复制

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzExample {
    public static void main(String[] args) throws SchedulerException {
        // 创建调度器
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // 定义任务
        JobDetail job = JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob", "group1")
                .build();

        // 定义触发器（每 5秒 触发一次）
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(5)
                        .repeatForever())
                .build();

        // 启动调度器
        scheduler.scheduleJob(job, trigger);
        scheduler.start();
    }

    public static class MyJob implements Job {
        @Override
        public void execute(JobExecutionContext context) {
            System.out.println("任务执行: " + new java.util.Date());
        }
    }
}

优点：

• 功能强大，支持复杂的调度任务。

• 支持分布式调度。

• 支持 Cron 表达式和多种触发器类型。

缺点：

• 配置复杂，学习成本较高。

5. 使用 Java 8 的 CompletableFuture 或 ScheduledExecutorService 组合

在 Java 8 中，可以使用 CompletableFuture 和 ScheduledExecutorService 的组合来实现更智能的定时任务。

java复制

import java.util.concurrent.*;

public class CompletableFutureExample {
    public static void main(String[] args) {
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

        // 定义一个定时任务
        Runnable task = () -> System.out.println("任务执行: " + new java.util.Date());

        // 安排任务在 1秒 后执行，之后每隔 2秒 执行一次
        scheduler.scheduleAtFixedRate(task, 1, 2, TimeUnit.SECONDS);
    }
}

优点：

• 灵活性高，可以根据需求定制复杂的调度逻辑。

• 支持多线程和并行任务。

缺点：

• 需要手动管理线程池，增加了代码复杂性。

总结

• 简单任务：使用 Timer 或 ScheduledExecutorService。

• Spring 应用程序：使用 @Scheduled 注解。

• 复杂调度需求：使用 Quartz 框架。

• 智能调度：使用 CompletableFuture 或其他组合方式。