总结篇-定时调度任务的几种方式

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/m0_37499059/article/details/81479207

任务调度是指基于给定时间点，给定时间间隔或者给定执行次数自动执行任

1.前言

我们举一个简单的例子:创建一个thread，然后让它在while循环里一直运行着，通过sleep方法来达到定时任务的效果。这样可以快速简单的实现。

public static void main(String[] args) {
        final long timeInterval = 1000;
        Runnable runnable = new Runnable() {
            public void run() {
                while (true) {
                    System.out.println("Hello !!");
                    try {
                        Thread.sleep(timeInterval);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
    }

但这样很耗费系统资源，扩展性，满足业务需要都不是很好。

---

2.任务调度方式

Timer
ScheduledExecutor
JCronTab
开源工具包 Quartz

---

1) Timer

相信大家都已经非常熟悉 java.util.Timer 了，它是最简单的一种实现任务调度的方法
特点：in JDK，简洁，单线程

public static void main(String[] args){  
   Timer timer = new Timer();  
   timer.schedule(new TimerTask(){
        @Override  
        public void run() {  
           System.out.println("do sth...");  
        }  
    }, 1000, 2000);  
}

核心类是 Timer 和 TimerTask
Timer 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务。

---

2) ScheduledExecutor

鉴于 Timer 的上述缺陷，Java 5 推出了基于线程池设计的 ScheduledExecutor。其设计思想是，每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰。需要注意的是，只有当任务的执行时间到来时，ScheduedExecutor 才会真正启动一个线程，其余时间 ScheduledExecutor 都是在轮询任务的状态。

package io.renren.modules.job.task;

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

/**
 * @author lanxinghua
 * @date 2018/08/07 12:45
 * @description
 */
public class ScheduleExecutorTest implements Runnable {

    private String jobName="";

    public ScheduleExecutorTest(String jobName) {
        this.jobName = jobName;
    }

    @Override
    public void run() {
        System.out.println("executor "+jobName+Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
        ScheduleExecutorTest job1 = new ScheduleExecutorTest("job1");
        service.scheduleAtFixedRate(job1,1,1,TimeUnit.SECONDS);
        service.scheduleAtFixedRate(job1,2,1,TimeUnit.SECONDS);
    }
}

用 ScheduledExecutor 和 Calendar 实现复杂任务调度

Timer 和 ScheduledExecutor 都仅能提供基于开始时间与重复间隔的任务调度，不能胜任更加复杂的调度需求。比如，设置每星期二的 16:38:10 执行任务。该功能使用 Timer 和 ScheduledExecutor 都不能直接实现，但我们可以借助 Calendar 间接实现该功能。

计算出间隔时间，计算从当前时间到最近一次执行时间的时间间隔

long delay = earliestDateLong - currentDateLong;
//计算执行周期为一星期
long period = 7 * 24 * 60 * 60 * 1000;
ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
//从现在开始delay毫秒之后，每隔一星期执行一次job1
service.scheduleAtFixedRate(test, delay, period,
TimeUnit.MILLISECONDS);

可以看出，用上述方法实现该任务调度比较麻烦，这就需要一个更加完善的任务调度框架来解决这些复杂的调度问题。幸运的是，开源工具包 Quartz 与 JCronTab 提供了这方面强大的支持。

---

3) JCronTab

习惯使用 unix/linux 的开发人员应该对 crontab 都不陌生。Crontab 是一个非常方便的用于 unix/linux 系统的任务调度命令。JCronTab 则是一款完全按照 crontab 语法编写的 java 任务调度工具。

JCronTab 与 Quartz 相比，其优点在于，第一，支持多种任务调度的持久化方法，包括普通文件、数据库以及 XML 文件进行持久化；第二，JCronTab 能够非常方便地与 Web 应用服务器相结合，任务调度可以随 Web 应用服务器的启动自动启动；第三，JCronTab 还内置了发邮件功能，可以将任务执行结果方便地发送给需要被通知的人。

---

4) Quartz（重点了解）

Quartz是个开源JAVA库,可以简单看做以上三种的结合的扩展。

Scheduler：调度容器
Job：Job接口类
JobDetail ：Job的描述类，job执行时的依据此对象的信息反射实例化出Job的具体执行对象。
Trigger：存放Job执行的时间策略
JobStore： 存储作业和调度期间的状态
Calendar：指定排除的时间点（如排除法定节假日）

]

Quartz的主要线程有两类，负责调度的线程和负责Misfire（指错过了执行时间的作业）的线程，其中负责调度的线程RegularSchedulerThread是基于线程池的，而Misfire只有一个线程。 两类线程都会访问抽象为JobStore的层来获取作业策略或写入调度状态。JobStore也分持久化(JobStoreSupport)和非持久化(RAMJobStore)两种，使用场景大大不同.

Job:
使用者只需要创建一个 Job 的继承类，实现 execute 方法。JobDetail 负责封装 Job 以及 Job 的属性，并将其提供给 Scheduler 作为参数。每次 Scheduler 执行任务时，首先会创建一个 Job 的实例，然后再调用 execute 方法执行。Quartz 没有为 Job 设计带参数的构造函数，因此需要通过额外的 JobDataMap 来存储 Job 的属性。JobDataMap 可以存储任意数量的 Key，Value 对，例如：

jobDetail.getJobDataMap().put("myDescription", "my job description"); 
 jobDetail.getJobDataMap().put("myValue", 1998); 
 ArrayList<String> list = new ArrayList<String>(); 
 list.add("item1"); 
 jobDetail.getJobDataMap().put("myArray", list);


public void execute(JobExecutionContext context)
throws JobExecutionException {
//从context中获取instName，groupName以及dataMap
String instName = context.getJobDetail().getName();
String groupName = context.getJobDetail().getGroup();
JobDataMap dataMap = context.getJobDetail().getJobDataMap();
//从dataMap中获取myDescription，myValue以及myArray
String myDescription = dataMap.getString("myDescription");
int myValue = dataMap.getInt("myValue");        

Trigger:
Trigger 的作用是设置调度策略。Quartz 设计了多种类型的 Trigger，其中最常用的是 SimpleTrigger 和 CronTrigger。

public SimpleTrigger(String name, 
                       String group, 
                       Date startTime, 
                       Date endTime, 
                       int repeatCount, 
                       long repeatInterval)

CronTrigger 的用途更广，相比基于特定时间间隔进行调度安排的 SimpleTrigger，CronTrigger 主要适用于基于日历的调度安排。例如：每星期二的 16:38:10 执行，每月一号执行，以及更复杂的调度安排等。

Cron 表达式，由七个字段组成：

Seconds
Minutes
Hours
Day-of-Month
Month
Day-of-Week
Year (Optional field)

创建一个每十分钟执行的 CronTrigger，且从每小时的第三分钟开始执行：
0 3/10 * * * ?

创建一个每周一，周二，周三，周六的晚上 20:00 到 23:00，每半小时执行一次的 CronTrigger：
0 0/30 20-23 ? * MON-WED,SAT

创建一个每月最后一个周四，中午 11:30-14:30，每小时执行一次的 trigger：
0 30 11-14/1 ? * 5L

通配符 * 表示该字段可接受任何可能取值。例如 Month 字段赋值 * 表示每个月，Day-of-Week 字段赋值 * 表示一周的每天。
/ 表示开始时刻与间隔时段。例如 Minutes 字段赋值 2/10 表示在一个小时内每 20 分钟执行一次，从第 2 分钟开始。
? 仅适用于 Day-of-Month 和 Day-of-Week。? 表示对该字段不指定特定值。

CronTrigger cronTrigger = new CronTrigger("myTrigger", "myGroup"); 
 try { 
     cronTrigger.setCronExpression("0 0/30 20-13 ? * MON-WED,SAT"); 
 } catch (Exception e) { 
     e.printStackTrace(); 
 }

Job 与 Trigger 的松耦合设计是 Quartz 的一大特点，其优点在于同一个 Job 可以绑定多个不同的 Trigger，同一个 Trigger 也可以调度多个 Job，灵活性很强。

package io.renren.modules.job.task;

import com.alibaba.fastjson.JSON;
import org.quartz.*;
import org.quartz.impl.JobDetailImpl;
import org.quartz.impl.StdSchedulerFactory;

import java.util.Date;
import java.util.List;

/**
 * @author lanxinghua
 * @date 2018/08/07 14:09
 * @description
 */
public class QuartzTest implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        JobDetail jobDetail = jobExecutionContext.getJobDetail();
        System.out.println(jobDetail.getKey());
        System.out.println(jobDetail.getJobDataMap().get("type"));
    }


    public static void main(String[] args) throws SchedulerException {
        //创建一个Scheduler
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();
        //创建JobDetail，name,gruopname,类名
        JobDetail jobDetail = JobBuilder.newJob(QuartzTest.class)
                .withIdentity("jobname","jobgroup")
                .requestRecovery()
                .build();
        jobDetail.getJobDataMap().put("type","FULL");
        //创建一个每周触发的Trigger
        SimpleTrigger trigger = (SimpleTrigger) TriggerBuilder.newTrigger()
                .withIdentity("triggerName")
                .startAt(new Date())
                .build();
        scheduler.scheduleJob(jobDetail,trigger);
        scheduler.start();
        System.out.println(trigger.getJobKey());
    }
}

补充一个知识点：jobDetail.getKey()， trigger.getJobKey()

 JobDetail jobDetail = JobBuilder.newJob(QuartzTest.class)
                .withIdentity("task1")
                .requestRecovery()
                .build();
scheduler.scheduleJob(jobDetail,trigger);

jobDetail.getKey(): DEFAULT.task1
trigger.getJobKey() : DEFAULT.task1
TriggerKey triggerKey = TriggerKey.triggerKey(“task1”);

如果你设置withIdentity(“jobname”,”jobgroup”);那default就不是默认的组了。

Listener
除了上述基本的调度功能，Quartz 还提供了 listener 的功能。主要包含三种 listener：JobListener，TriggerListener 以及 SchedulerListener。当系统发生故障，相关人员需要被通知时，Listener 便能发挥它的作用。最常见的情况是，当任务被执行时，系统发生故障，Listener 监听到错误，立即发送邮件给管理员。

public class MyListener implements JobListener{

    @Override
    public String getName() {
        return "My Listener";
    }
    @Override
    public void jobWasExecuted(JobExecutionContext context,
            JobExecutionException jobException) {
        if(jobException != null){
            try {
                //停止Scheduler
                context.getScheduler().shutdown();
                System.out.println("
                Error occurs when executing jobs, shut down the scheduler ");
                // 给管理员发送邮件…
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    }
}

需要将 listener 的实现类注册到 Scheduler 和 JobDetail 中：

sched.addJobListener(new MyListener());
jobDetail.addJobListener(“My Listener”); // listener 的名字

使用者也可以将 listener 注册为全局 listener，这样便可以监听 scheduler 中注册的所有任务 :

sched.addGlobalJobListener(new MyListener());

---

3.总结

四种常用的对任务进行调度的 Java 实现方法，即 Timer，ScheduledExecutor, Quartz 以及 JCronTab。

1. 对于简单的基于起始时间点与时间间隔的任务调度，使用 Timer 就足够了；
2. 如果需要同时调度多个任务，基于线程池的 ScheduledTimer 是更为合适的选择；
3. 当任务调度的策略复杂到难以凭借起始时间点与时间间隔来描述时，Quartz 与 JCronTab 则体现出它们的优势。

熟悉 Unix/Linux 的开发人员更倾向于 JCronTab，且 JCronTab 更适合与 Web 应用服务器相结合。Quartz 的 Trigger 与 Job 松耦合设计使其更适用于 Job 与 Trigger 的多对多应用场景。