背景

在日常的开发工作中我们经常会遇到定时任务的相关问题，比如：

• 信用卡定时每月给用户推送账单数据；
• 轮训更新某个任务的状态是否完成；
• 设置一个定时提醒；
• 邮件或消息设置定时发送；
• 定时统计某个时间段的数据存入缓存；

等等，定时可以算一个最常用的开发工作，你日常的工作中肯定也写了不少的定时任务代码，但是你真的了解定时任务吗？

下面让我们一起进入定时任务的学习！

一、基础

1.1 Cron表达式

cron是当前做定时任务的基础，即使很多人说cron表达式不容易理解，但这是现在阶段所有程序编写定时任务的基础和唯一选择。

就算做不到熟练编写，也应该做到看到能懂；

Cron表达式是一个字符串，字符串以5或6个空格隔开，分为6或7个域，每一个域代表一个含义；

接下来具体看cron属性对应时间表达式的定义规则：

1. 按顺序依次是：秒、分、时、日、月、周，中间用空格间隔
2. 月、周可以用数字或英文单词的前三个字母表示
3. 日和周可能会冲突，因此两个可以有一个配置为?
4. 常用通配符的含义：
   • *表示任意值，例如在秒字段上设置*，表示每秒都触发
   • ?表示不指定值，只能出现在日或者周的位置，用于处理日和周可能存在的冲突，例如2020年8月15是周六，如果又在周的位置上指定为周一，那就会产生冲突到导致定时任务失效。如果我们不关心日或者周的时候，也可以将其设置为?
   • -表示时间区间，例如在秒上设置1-3，表示第1、2、3秒都会触发
   • /表示时间间隔，例如在秒上设置2/4，表示从第2秒开始每间隔4秒触发一次
   • ,表示列举多个值，例如MON,WED,FRI表示周一、周三、周五触发

例如：

• 每隔5秒执行一次：*/5 * * * * ?
• 每隔1分钟执行一次：0 */1 * * * ?
• 每天23点执行一次：0 0 23 * * ?
• 每天凌晨1点执行一次：0 0 1 * * ?
• 每月1号凌晨1点执行一次：0 0 1 1 * ?
• 每月最后一天23点执行一次：0 0 23 L * ?
• 每周星期天凌晨1点实行一次：0 0 1 ? * L
• 在26分、29分、33分执行一次：0 26,29,33 * * * ?
• 每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?

1.2 定时任务的三大组成部分

调度器Scheduler、执行器 executors、触发器 Trigger

不管你使用的什么框架、用的是什么系统，或者将来又出现什么新的定时任务技术，都离不开这三部分。

我们以一个闹钟响铃的任务为例：

• 执行器executors：发出一阵刺耳的声音；（具体的执行操作）
• 触发器Trigger：发出声音的具体时间； （触发任务执行的规则，多为时间规则。）
• 调度器Scheduler：一直运行到触发时间点发出刺耳的声音；（进行任务的调度）

所以，当接手一个新的定时任务的框架，首先要看其这三部分是这么去实现的；

二、Java做定时任务的技术方案比较

Java做定时任务的技术方案有多种，本文将比较常见的技术方案，分析它们的优缺点，以便开发人员在实际项目中选择合适的技术方案。

2.1、JDK seelp实现定时任务

• 使用Thread.sleep()方法实现定时任务。可以在独立的线程中执行任务，并在每次任务完成后使用Thread.sleep()方法让线程休眠一段时间。
• 下面是一个示例，该示例定义了一个任务，该任务每隔1秒打印“hello timer”：

public class TimerExample {public static void main(String[] args) { Runnable task = new Runnable() { public void run() { while (true) { System.out.println("hello timer"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }; Thread thread = new Thread(task); thread.start(); } 
}

• 请注意，在本例中，任务是在无限循环中执行的，并且每次任务完成后线程都会休眠1秒。如果想要执行特定次数的定时任务，可以在任务内部使用计数器并在达到特定次数后终止循环。

2.2、JDK Timer & TimerTask 实现定时任务

使用Java的java.util.Timer和java.util.TimerTask类来创建定时任务。

• 下面是一个简单的例子，其中定义了一个任务，该任务每隔1秒执行一次：

  import java.util.Timer; 
  import java.util.TimerTask; public class TimerExample { public static void main(String[] args) { TimerTask task = new TimerTask() { public void run() { System.out.println("Task executed"); } }; Timer timer = new Timer(); long delay = 1000; long interval = 1000; timer.scheduleAtFixedRate(task, delay, interval); } 
  }
  

• 在上面的代码中，创建了一个TimerTask对象，该对象的run方法定义了要执行的任务。然后，使用Timer类创建了一个定时器，并使用scheduleAtFixedRate方法指定了任务的执行频率（即每隔1秒执行一次）。

  请注意，java.util.Timer是非线程安全的，因此在多线程环境中使用时需要注意。

  如果需要更复杂的定时任务，请考虑使用其他库，例如java.util.concurrent中的ScheduledExecutorService。

• 在Java 5之前，它是唯一的定时任务工具，在Java 5之后，JDK提供了更好的替代方案。

  • 优点：

    • 轻量级，使用简单。
    • 可以实现较为简单的定时任务功能。

  • 缺点：

    • 不支持复杂的定时任务类型，如cron表达式
    • 不支持任务持久化
    • 在定时任务数量很多的情况下，性能可能存在问题
    • 不支持分布式

2.3、JDK ScheduledExecutorService

• ScheduledExecutorService是Java 5新增的一个接口，它位于java.util.concurrent包内，可以通过ThreadPoolExecutor来实现。可以使用它创建和执行定期执行的任务，并且可以控制任务的执行频率。
  它可以很方便地实现定时任务，支持多种执行方式，比如单次定时、固定频率定时和固定延迟时间定时等。

• 以下是一个示例，该示例每隔1秒钟打印“hello timer”：

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 executor = Executors.newScheduledThreadPool(1); Runnable task = new Runnable() { public void run() { System.out.println("hello timer");} }; executor.scheduleAtFixedRate(task, 0, 1, TimeUnit.SECONDS); } 
}

• 在本例中，使用Executors类的newScheduledThreadPool方法创建了一个ScheduledExecutorService对象，并使用该对象的scheduleAtFixedRate方法将任务安排在每隔1秒钟执行一次。可以根据需要更改任务的执行频率。

• 优点：

  • 简单易用，可灵活配置。
  • 支持多种定时任务类型，灵活度高。
  • 支持并发调度，可以提高性能。

• 缺点：

  • 不支持分布式
  • 任务执行结果管理不够方便

2.4、Quartz框架

• Quartz是一个流行的开源的定时任务框架，支持非常丰富的定时任务类型，比如简单定时任务、复杂定时任务、集群定时任务、任务持久化等。

• 以下是一个使用Quartz创建定时任务的示例：

  import org.quartz.*; 
  import org.quartz.impl.StdSchedulerFactory; public class QuartzExample { public static void main(String[] args) throws SchedulerException { JobDetail job = JobBuilder.newJob(HelloJob.class).withIdentity("myJob", "group1").build(); Trigger trigger = TriggerBuilder.newTrigger() .withIdentity("myTrigger", "group1") .startNow() .withSchedule(SimpleScheduleBuilder.simpleSchedule() .withIntervalInSeconds(1) .repeatForever()) .build(); Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler(); scheduler.start();scheduler.scheduleJob(job, trigger); } 
  }public class HelloJob implements Job {public void execute(JobExecutionContext context) {System.out.println("hello timer");} 
  }
  

• 在本例中，创建了一个名为HelloJob的作业类，该类实现了Quartz的Job接口。
  还创建了一个作业详细信息对象和一个触发器对象，并使用触发器安排了每隔1秒钟执行一次的任务。最后，启动了调度程序并使用其scheduleJob方法将任务与触发器关联。

• 优点：

  • 功能丰富，支持多种定时任务类型。
  • 支持任务持久化，保证任务不会丢失。
  • 支持分布式，可以实现任务的高可用和负载均衡。

• 缺点：

  • 依赖比较大，使用起来比较复杂。
  • 配置较为繁琐，需要考虑集群和持久化等问题。

2.5、Spring Task 中的 @schedule

• Spring Task是Spring框架提供的一个模块，可以用来进行定时任务的管理。通过@Scheduled注解，可以实现简单的定时任务设置。同时也支持通过cron表达式设置复杂的定时任务。

• 以下是一个示例，该示例每隔1秒钟打印“hello timer”：

  import org.springframework.scheduling.annotation.Scheduled; public class ScheduledAnnotationExample { @Scheduled(fixedRate = 1000) public void printMessage() { System.out.println("hello timer"); } 
  }
  

• 在本例中，使用@Scheduled注解将任务标记为定时任务，并使用fixedRate属性设置任务的执行频率，即每隔1秒钟执行一次。

• 优点：

  • 集成简单，开发便捷。
  • 支持使用注解来配置定时任务，使得代码更加易读易维护。

• 缺点：

  • 不支持分布式
  • 不支持任务持久化

2.6、Elastic-Job框架

• Elastic-Job是一个分布式作业调度框架，提供了高可用性、高扩展性等功能，可以用于创建分布式定时任务。

• 以下是使用Elastic-Job创建一个简单的定时任务的示例：

  import com.dangdang.ddframe.job.api.ShardingContext; 
  import com.dangdang.ddframe.job.api.simple.SimpleJob; 
  public class MyJob implements SimpleJob { @Override public void execute(ShardingContext shardingContext) { System.out.println("Hello, world!"); } 
  }
  

• 在本例中，创建了一个名为MyJob的作业类，该类实现了Elastic-Job的SimpleJob接口。可以在execute方法中编写定时执行的代码。还需要创建一个作业配置文件，该文件配置了任务的定时时间和任务的执行策略。

2.7、PowerJob框架

• PowerJob是一种使用Java语言编写的分布式任务调度系统，可以用于创建定时任务。

• 以下是使用PowerJob创建一个简单的定时任务的示例：

  import com.dangdang.ddframe.job.api.ShardingContext; 
  import com.dangdang.ddframe.job.api.simple.SimpleJob; 
  import org.slf4j.Logger; 
  import org.slf4j.LoggerFactory; public class MyJob implements SimpleJob { private static final Logger logger = LoggerFactory.getLogger(MyJob.class); @Override public void execute(ShardingContext shardingContext) { logger.info("Hello, world!"); } 
  }
  

• 在本例中，创建了一个名为MyJob的简单作业类，该类实现了PowerJob的SimpleJob接口。可以在execute方法中编写定时执行的代码。

2.8、Xxl-job

• Xxl-job是一个Java分布式定时任务解决方案，提供了高可用性、高扩展性等功能，可以用于创建分布式定时任务。可以用来代替Quartz。它支持类似cron表达式的定时任务设置，支持多种执行器类型，比如本地任务、Shell任务、Http任务等。同时还支持任务执行结果的管理和调度中心的高可用等特性。

• 以下是使用XXL-JOB创建一个简单的定时任务的示例：

  import com.xxl.job.core.biz.model.ReturnT; 
  import com.xxl.job.core.handler.IJobHandler; 
  import com.xxl.job.core.handler.annotation.JobHandler; 
  import com.xxl.job.core.log.XxlJobLogger; 
  import org.springframework.stereotype.Component; 
  @JobHandler(value="myJobHandler") 
  @Component 
  public class MyJobHandler extends IJobHandler { @Override public ReturnT<String> execute(String param) throws Exception { XxlJobLogger.log("Hello, world!"); return SUCCESS; } 
  }  
  

• 在本例中，创建了一个名为MyJobHandler的作业类，该类继承了XXL-JOB的IJobHandler类。可以在execute方法中编写定时执行的代码。
  还需要通过注解@JobHandler声明作业处理器名称，并在作业配置中将作业处理器与作业关联。

• 优点：

  • 操作简单，集成容易。
  • 多种任务执行器类型，支持更多的任务类型。
  • 支持可视化的调度中心，调度管理更加方便。

• 缺点：

  • 比较适合定时任务数量较多，任务类型较为丰富的情况，对于简单的定时任务使用稍显繁琐。

三、共同点和不同点

技术方案	共同点	不同点
Thread.sleep()	简单易用	不支持复杂的定时任务类型，不支持分布式
Timer类	简单易用，轻量级	不支持复杂的定时任务类型，不支持分布式
ScheduledExecutorService	简单易用，支持多种定时任务类型，可灵活配置，支持并发调度	不支持分布式，任务执行结果管理不够方便
Quartz框架	支持多种定时任务类型，支持分布式、任务持久化	配置较为繁琐，依赖比较大
Elastic-Job框架	支持多种定时任务类型，支持分布式、任务持久化	配置较为复杂
PowerJob框架	支持多种定时任务类型，支持分布式、任务持久化po	配置较为繁琐
Spring Task	集成简单，支持注解配置	不支持分布式，不支持任务持久化
Xxl-job	操作简单，支持多种任务执行器类型，支持可视化的调度中心成就管理	比较适合定时任务数量较多，任务类型较为丰富的情况

总结

总的来说，各个技术方案都有它们的优缺点，根据实际业务需求、技术需求和团队技术状况等，选择合适的技术方案是非常重要的。