springboot实现定时器的3种方法

springboot实现定时器

       ## 1.基于注解  @Scheduled
       ## 2.基于接口 SchedulingConfigurer
       ## 基于多线程

基于注解的方式 @Scheduled

package com.kusen.mq.rabbitmq.task;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;

import java.time.LocalDateTime;

/**
 * @fileName：Schedule
 * @createTime：2021/9/28
 * @author：
 * @version：
 * @description：基于注解(@Scheduled)的简单定时器demo
 *
 * cron表达式语法:[秒] [分] [小时] [日] [月] [周] [年]
 * @Scheduled(fixedDelay = 5000) //上一次执行完毕时间点之后5秒再执行
 * @Scheduled(fixedDelayString = "5000") //上一次执行完毕时间点之后5秒再执行
 * @Scheduled(fixedRate = 5000) //上一次开始执行时间点之后5秒再执行
 * @Scheduled(initialDelay=1000, fixedRate=5000) //第一次延迟1秒后执行，之后按fixedRate的规则每5秒执行一次
 *
 */


//1.主要用于标记配置类
@Configuration
// 2.开启定时任务
@EnableScheduling
public class ScheduleTask {
    //3.添加定时任务
    @Scheduled(cron = "0/5 * * * * ?")
    //或直接指定时间间隔，例如：5秒
    //@Scheduled(fixedRate=5000)
    private void configureTasks() {
        System.out.println("基于注解(@Scheduled)的简单定时器demo: " + LocalDateTime.now());
    }
}

基于接口方式实现 核心接口：SchedulingConfigurer
定义一个抽象类。实现了SchedulingConfigurer接口 这是方便其他定时任务对其扩展和动态添加

 基于SchedulingConfigurer 实现的父类

package com.kusen.mq.rabbitmq.scheduling;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;


import java.util.concurrent.*;

/**
 * @fileName：ConfigurerScheduling
 * @createTime：2021/9/28
 * @author： ghl
 * @version：
 * @description：基于接口SchedulingConfigurer的动态定时任务
 */
@Configuration
@EnableScheduling
public abstract class ConfigurerScheduling implements SchedulingConfigurer {
    /**
     * @brief 定时任务名称
     */
    private String schedulerName;

    /**
     * @brief 定时任务周期表达式
     */
    private String cron;

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(taskScheduler());
        taskRegistrar.addTriggerTask(() -> {
            if(isWork()){
                processTask();
            }
        }, triggerContext -> {
//            if (StringUtils.isEmpty(cron)) {
//                cron = getCron();
//            }
            cron = getCron();
            return new CronTrigger(cron).nextExecutionTime(triggerContext);
        });
    }

    /**
     * 留给子类的抽象方法 子类真正去做事情的方法
     */
    public abstract void processTask();

    /**
     * @return String
     * @brief 获取定时任务周期表达式
     * 本函数由派生类实现，从配置文件，数据库等方式获取参数值
     * @author ghl
     */
    protected abstract String getCron();

    /**
     * 判断是否要开始任务
     * @return
     */
    protected abstract Boolean isWork();

    /**
     * 设置TaskScheduler用于注册计划任务
     *
     * @return
     */
    @Bean(destroyMethod = "shutdown")
    public Executor taskScheduler() {
        //设置线程名称
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
        //创建线程池
        return Executors.newScheduledThreadPool(5, namedThreadFactory);
    }

}

子类实现

package com.kusen.mq.rabbitmq.task;

import com.kusen.mq.rabbitmq.scheduling.ConfigurerScheduling;
import org.springframework.context.annotation.Configuration;

import java.time.LocalDateTime;

/**
 * 任务1 操作数据库
 * @author ghl
 */
 //将这个任务交给spring容器管理
@Configuration
public class TaskDemo1 extends ConfigurerScheduling {

    @Override
    public void processTask() {
        System.out.println("基于接口SchedulingConfigurer的动态定时任务 任务性质是每隔5秒从数据库中查询数据:"
                + LocalDateTime.now() + "，线程名称：" + Thread.currentThread().getName()
                + " 线程id：" + Thread.currentThread().getId());
    }

    @Override
    protected String getCron() {
        return "*/5 * * * * ?";
    }
 /**
 *子类实现的是否要开启这个定时任务 
 * @author ghl
 */
    @Override
    protected Boolean isWork() {
        return true;
    }
}

package com.kusen.mq.rabbitmq.task;

import com.kusen.mq.rabbitmq.config.DynamicScheduleTask;
import com.kusen.mq.rabbitmq.scheduling.ConfigurerScheduling;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;

/**
 *从数据库中获取到定时时候执行定时任务
 */
@Configuration
public class TaskDemo4 extends ConfigurerScheduling {
    @Autowired      //注入mapper
    @SuppressWarnings("all")
    DynamicScheduleTask.CronMapper cronMapper;
    private Map<Integer,String> cache =new HashMap<>();

    /**
     * 真正处理定时任务的方法
     */
    @Override
    public void processTask() {
        System.out.println("基于接口SchedulingConfigurer的动态定时任务:时间任务从数据库中动态获取执行获取"
                + LocalDateTime.now() + "，线程名称：" + Thread.currentThread().getName()
                + " 线程id：" + Thread.currentThread().getId());
    }

    /**
     * 从数据库中获取到定时任务的的时间
     * @return
     */
    @Override
    protected String getCron() {
        String cron = cronMapper.getCron();
        return cron;
    }

    @Override
    protected Boolean isWork() {
        return true;
    }
}

基于多线程方式

package com.kusen.mq.rabbitmq.task;

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

/**
 * 基于多线程的方式实现定时任务
 * @author ghl
 */
@Component
@EnableScheduling   // 1.开启定时任务
@EnableAsync        // 2.开启多线程
public class MultithreadScheduleTask {
    @Async
    @Scheduled(fixedDelay = 1000)  //间隔1秒
    public void first() throws InterruptedException {
        System.out.println("第一个定时任务开始 : " + LocalDateTime.now().toLocalTime() + "\r\n线程 : " + Thread.currentThread().getName());
        System.out.println();
        Thread.sleep(1000 * 10);
    }
    @Async
    @Scheduled(fixedDelay = 2000)
    public void second() {
        System.out.println("第二个定时任务开始 : " + LocalDateTime.now().toLocalTime() + "\r\n线程 : " + Thread.currentThread().getName());
        System.out.println();
    }

}