Java中的定时任务应用

一. 使用Java的Timer

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TimerUtil {

    public static void playOne() {
        new Timer("Timer1").schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("TimerTask1");
            }
        }, 1000, 2000);
    }

    public static void playTwo() throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = simpleDateFormat.parse("2023-08-10 10:14:00");
        new Timer("Timer2").scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println("TimerTask2");
            }
        },date,2000);
    }

}

• date是开始时间，2000ms是定时任务周期，每2s执行一次

• timer有2种方法：schedule和scheduleAtFixedRate，前者会等任务结束再开始计算时间间隔，后者是在任务开始就计算时间，有并发的情况

二. 使用ScheduledExecutorService

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

public class ScheduleUtil {

    public static void playThree(){
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("ScheduledTask1");
            }
        },1,1, TimeUnit.SECONDS);
    }
}

延迟1s启动，每隔1s执行一次，在前一个任务开始时就开始计算时间间隔，但会等上一个任务结束再开始下一个

三. 使用SpringTask

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

@Service
public class SpringTask {
    private static final Logger log = LoggerFactory.getLogger(SpringTask.class);

    @Scheduled(cron = "1/5 * * * * *")
    public void task1() {
        log.info("SpringTask1 定时任务1");
    }

    @Scheduled(initialDelay = 1, fixedRate = 1 * 1000)
    public void task2(){
        log.info("SpringTask2 定时任务2");
    }
}

• task1是每隔5s执行一次，{秒} {分} {时} {日期} {月} {星期}；

• task2是延迟1s，每隔1S执行一次。

四. 使用Quartz框架

添加依赖

    
            org.springframework.boot
            spring-boot-starter-quartz
        

编写quartz.properties

# ThreadPool 实现的类名
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
# 线程数量
org.quartz.threadPool.threadCount=10
# 线程优先级
org.quartz.threadPool.threadPriority=5
# 自创建父线程
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread= true

编写配置类

import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import java.io.IOException;
import java.util.Properties;

@Configuration
@EnableScheduling
public class SchedulerConfig {

    @Bean(name = "SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setQuartzProperties(quartzProperties());
        return factory;
    }

    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        //在quartz.properties中的属性被读取并注入后再初始化对象
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

    /**
     * quartz初始化监听器
     */
    @Bean
    public QuartzInitializerListener executorListener() {
        return new QuartzInitializerListener();
    }

    /**
     * 通过SchedulerFactoryBean获取Scheduler的实例
     */
    @Bean(name = "Scheduler")
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }
}

编写具体要执行的定时任务

import org.quartz.*;
import java.time.LocalDateTime;

/**
 * 例子：定义一个执行输出语句的任务
 */
public class HelloJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Hello执行：" + LocalDateTime.now());
    }
}

测试类

import com.example.ratelimit.demos.util.HelloJob;
import org.junit.jupiter.api.Test;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Date;

@SpringBootTest
class RateLimitApplicationTests {

    @Test
    void contextLoads() {
    }

    @Test
    public void quartzTest() throws SchedulerException {
        // 1. 创建工厂类 SchedulerFactory
        SchedulerFactory factory = new StdSchedulerFactory();
        // 2. 通过 getScheduler() 方法获得 Scheduler 实例
        Scheduler scheduler = factory.getScheduler();
        scheduler.clear();
        // 3. 使用上文定义的 HelloJob
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
                //job 的name和group
                .withIdentity("jobName2", "jobGroup2")
                .build();
        //3秒后启动任务
        Date statTime = new Date(System.currentTimeMillis() + 3000);
        // 4. 启动 Scheduler
        scheduler.start();
        // 5. 创建Trigger
        //使用SimpleScheduleBuilder或者CronScheduleBuilder
        SimpleTrigger simpleTrigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger", "group")
                .startAt(new Date())
                .withSchedule(
                        SimpleScheduleBuilder.simpleSchedule()
                                .withIntervalInSeconds(3)
                                .withRepeatCount(0))//重复执行的次数，因为加入任务的时候马上执行了，所以不需要重复，否则会多一次。
                .build();
        // 6. 注册任务和定时器
        scheduler.scheduleJob(jobDetail, simpleTrigger);
    }
}