springboot实现定时任务的方式

a Timer：这是java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。
b ScheduledExecutorService：也jdk自带的一个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。
c Spring Task：Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多。
d Quartz：这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂

使用Timer

以下是几种调度task的方法：

timer.schedule(task, time);
// time为Date类型：在指定时间执行一次。

timer.schedule(task, firstTime, period);
// firstTime为Date类型,period为long
// 从firstTime时刻开始，每隔period毫秒执行一次。

timer.schedule(task, delay)
// delay 为long类型：从现在起过delay毫秒执行一次

timer.schedule(task, delay, period)
// delay为long,period为long：从现在起过delay毫秒以后，每隔period
// 毫秒执行一次。

public class TestTimer {
    public static void main(String[] args) {
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                System.out.println("task  run:"+ new Date());
            }
        };
        Timer timer = new Timer();
        //安排指定的任务在指定的时间开始进行重复的固定延迟执行。这里是每3秒执行一次
        timer.schedule(timerTask,10,3000);
    }
}

这个目前在项目中用的较少，直接贴demo代码。具体的介绍可以查看api

springboot实现定时任务的俩种方式

1、springboot集成schedule实现定时任务

2、SpringBoot整合quartz实现定时任务

使用schedule实现定时任务（联合bc）

1.1 添加maven依赖包

由于Spring Schedule包含在spring-boot-starter基础模块中了，所有不需要增加额外的依赖。

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>
 
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
</dependencies>

1.2 启动类，添加启动注解

在springboot入口或者配置类中增加@EnableScheduling注解即可启用定时任务。

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

1.3.添加定时任务

Spring Schedule三种任务调度器

类似于Linux下的Cron表达式时间定义规则。Cron表达式由6或7个空格分隔的时间字段组成，如下图：

常用表达式：

举个栗子：

添加一个work()方法，每10秒执行一次。

注意：当方法的执行时间超过任务调度频率时，调度器会在下个周期执行。

如：假设work()方法在第0秒开始执行，方法执行了12秒，那么下一次执行work()方法的时间是第20秒。

@Component
public class MyTask {
    @Scheduled(cron = "0/10 * * * * *")
    public void work() {
        // task execution logic
    }
}

1.3.2 固定间隔任务

下一次的任务执行时间，是从方法最后一次任务执行结束时间开始计算。并以此规则开始周期性的执行任务。

举个栗子：

添加一个work()方法，每隔10秒执行一次。

例如：假设work()方法在第0秒开始执行，方法执行了12秒，那么下一次执行work()方法的时间是第22秒。

@Scheduled(fixedDelay = 1000*10)
public void work() {
    // task execution logic
}

1.3.3 固定频率任务

按照指定频率执行任务，并以此规则开始周期性的执行调度。

举个栗子：

添加一个work()方法，每10秒执行一次。

注意：当方法的执行时间超过任务调度频率时，调度器会在当前方法执行完成后立即执行下次任务。

例如：假设work()方法在第0秒开始执行，方法执行了12秒，那么下一次执行work()方法的时间是第12秒。

@Scheduled(fixedRate = 1000*10)
public void work() {
    // task execution logic
}

2、配置TaskScheduler线程池

在实际项目中，我们一个系统可能会定义多个定时任务。那么多个定时任务之间是可以相互独立且可以并行执行的。

通过查看org.springframework.scheduling.config.ScheduledTaskRegistrar源代码，发现spring默认会创建一个单线程池。这样对于我们的多任务调度可能会是致命的，当多个任务并发（或需要在同一时间）执行时，任务调度器就会出现时间漂移，任务执行时间将不确定。

protected void scheduleTasks() {
    if (this.taskScheduler == null) {
        this.localExecutor = Executors.newSingleThreadScheduledExecutor();
        this.taskScheduler = new ConcurrentTaskScheduler(this.localExecutor);
    }
    //省略...
}

2.1 自定义线程池

新增一个配置类，实现SchedulingConfigurer接口。重写configureTasks方法，通过taskRegistrar设置自定义线程池。

/** * @author:  * @date: 2019/4/18 14:55 * @description:spring提供的定时任务默认是单线程,会造成任务执行时间偏移,所以此处用自定义的线程池 */@Configurationpublic class ScheduleConfig implements SchedulingConfigurer {    @Override    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {        taskRegistrar.setScheduler(getExecutor());    }    @Bean(destroyMethod = "shutdown")    public ExecutorService getExecutor() {        return new ScheduledThreadPoolExecutor(20);    }}

3、实际应用中的问题

3.1 Web应用中的启动和关闭问题

我们知道通过spring加载或初始化的Bean，在服务停止的时候，spring会自动卸载（销毁）。但是由于线程是JVM级别的，如果用户在Web应用中启动了一个线程，那么这个线程的生命周期并不会和Web应用保持一致。也就是说，即使Web应用停止了，这个线程依然没有结束（死亡）。

解决方法：

1）当前对象是通过spring初始化

spring在卸载（销毁）实例时，会调用实例的destroy方法。通过实现DisposableBean接口覆盖destroy方法实现。在destroy方法中主动关闭线程。

@Component
public class MyTask implements DisposableBean{
    @Override
    public void destroy() throws Exception {
        //关闭线程或线程池
        ThreadPoolTaskScheduler scheduler = (ThreadPoolTaskScheduler)applicationContext.getBean("scheduler");
        scheduler.shutdown();
    }
    //省略...
}

2）当前对象不是通过spring初始化（管理）

那么我们可以增加一个Servlet上下文监听器，在Servlet服务停止的时候主动关闭线程。

public class MyTaskListenter implements ServletContextListener{
    @Override
    public void contextDestroyed(ServletContextEvent arg0) {
        //关闭线程或线程池
    }
    //省略...
}

3.2 分布式部署问题

在实际项目中，我们的系统通常会做集群、分布式或灾备部署。那么定时任务就可能出现并发问题，即同一个任务在多个服务器上同时在运行或者将定时任务部署到单独一台服务器上。

解决方法（分布式锁）：

1）通过数据库表锁

2）通过缓存中间件

3）通过Zookeeper实现

4）通过redis的key实现，

在执行定时任务时，定义一个key值，获得本机hostname,存入redis，进行判断，这样就只会一台在执行任务

@Scheduled(cron = "0 */1 *  * * * ")
    public void reportCurrentByCron(){

        RedisUtil redisUtil = RedisUtil.getInstance(redisConfig);
        try {
            String hostName = HostUtil.getHostName()+ HostUtil.getIp();
            if (!redisUtil.exists(cronKey)){
                redisUtil.setex(cronKey,hostName,24*60*60);
                logger.info("首次执行："+hostName);
            }else {
                String value = redisUtil.get(cronKey);
                if (!hostName.equals(value)){
                    logger.info("hostName不一致");
                    return;
                }
                redisUtil.setex(cronKey,hostName,24*60*60);
            }
        }catch (Exception e){
            logger.error("redis异常",e);
        }
        /**开始执行*/
        System.out.println ("Scheduling Tasks Examples By Cron: The time is now " + dateFormat ().format (new Date()));
    }

quartz实现定时任务

quartz数据库官方脚本

来源：https://www.cnblogs.com/h-c-g/p/10729597.html

标签

线程池

work