我要评论一、定时任务
概念
定时任务是一种自动化执行特定操作的方式，可以根据预定的时间、日期或间隔周期性地执行某些任务。
在平常的生活中，大家肯定是有设置闹钟的习惯，我们需要通过闹钟来提醒我们到这个时刻，我们应该做指定的事情。同样的在编程当中，我们很多时候也是需要实现这样的操作的，到达指定的时刻，我们想要我们的程序去执行某一个事情，比如：指定时间发送邮箱、指定时间发送生日祝福……
以上的种种到达指定时间做指定事情，就是定时任务。
作用
- 自动化任务执行：定时任务能够在预定的时间触发执行某些任务，无需人工干预。这对于需要定期执行的重复性任务非常有效，例如数据备份、统计报表生成、系统维护等。
- 提高效率和准确性：通过定时任务，可以在特定的时间段内自动执行任务，避免了人工操作的疏忽和错误。这样可以提高任务的执行效率和准确性，并降低因人为原因导致的错误风险。
- 节省时间和资源：定时任务可以代替人工手动执行的操作，节省了大量人力资源和时间成本。同时，它也可以合理分配系统资源，避免任务集中导致的系统负载过高。
- 异步执行：定时任务可以在后台异步执行，不会阻塞用户的其他操作。这对于需要执行耗时较长的任务或需要长时间运行的操作非常有用，可以提高系统的响应速度和用户体验。
二、简单定时任务实现方式
今天我们来讨论一下在java中如何实现定时任务。定时任务在很多场景下都非常有用，例如定期执行清理工作、数据备份、发送通知等。
在java中，常见的可以实现定时任务的方式有如下几种：
（1）线程类实现定时任务：比如thread、runnable、callable等线程类都可以实现定时任务。
（2）timer/timertask：java提供了java.util.timer和java.util.timertask类，可以用于创建定时任务。通过创建一个timer对象，并调用其schedule()方法，可以指定任务的执行时间和执行间隔。然后，创建一个继承自timertask的子类，实现具体的任务逻辑，并在run()方法中定义需要执行的代码。最后，将该任务对象通过timer的schedule()方法进行调度即可。
（3）scheduledexecutorservice：java提供了java.util.concurrent.scheduledexecutorservice接口，可以用于创建定时任务。通过调用scheduledexecutorservice的scheduleatfixedrate()或schedulewithfixeddelay()方法，可以指定任务的执行时间和执行间隔。然后，创建一个实现了runnable接口的类，实现具体的任务逻辑，并在run()方法中定义需要执行的代码。最后，将该任务对象提交给scheduledexecutorservice进行调度即可。
（4）@scheduled注解：这个是spring框架所提供的，通过在方法上添加@scheduled注解，并设置相应的时间表达式，就可以让方法按照指定的时间间隔自动执行。
1. thread线程等待（最原始最简单方式）
创建一个thread，然后让它在while循环里一直运行着，通过sleep方法来达到定时任务的效果。
/**
* 匿名内部类实现 java.lang.runnable 接口
*/
public class threadtask {
public static void main(string[] args) {
final long timeinterval = 1000;
//创建线程(匿名内部类方式)
thread thread = new thread(new runnable() {
@override
public void run() {
while (true){
simpledateformat sdf = new simpledateformat("hh:mm:ss.sss");
string datestr = sdf.format(new date());
system.out.println("线程等待实现定时任务：" + datestr);
try {
thread.sleep(timeinterval);
} catch (interruptedexception e) {
e.printstacktrace();
}
}
}
});
//开启线程
thread.start();
}
}public class threadtask1 {
public static void main(string[] args) {
myrunnable runnable = new myrunnable();
//创建线程(自定义类myrunnable实现java.lang.runnable接口)
thread t = new thread(runnable);
//开启线程
t.start();
}
}
/**
* 自定义类myrunnable实现java.lang.runnable接口
*/
class myrunnable implements runnable{
final long timeinterval = 1000;
@override
public void run() {
while (true){
simpledateformat sdf = new simpledateformat("hh:mm:ss.sss");
string datestr = sdf.format(new date());
system.out.println("线程等待实现定时任务1：" + datestr);
try {
thread.sleep(timeinterval);
} catch (interruptedexception e) {
e.printstacktrace();
}
}
}
}2. 使用java.util.timer
jdk自带的timer api算是最古老的定时任务实现方式了。timer是一种定时器工具，使用java.util.timer工具类。用来在一个后台线程计划执行指定任务。它可以安排任务“执行一次”或者定期“执行多次”。
timer类核心方法如下：
// 在指定延迟时间后执行指定的任务 schedule(timertask task,long delay); // 在指定时间执行指定的任务。（只执行一次） schedule(timertask task, date time); // 延迟指定时间（delay）之后，开始以指定的间隔（period）重复执行指定的任务 schedule(timertask task,long delay,long period); // 在指定的时间开始按照指定的间隔（period）重复执行指定的任务 schedule(timertask task, date firsttime , long period); // 在指定的时间开始进行重复的固定速率执行任务 scheduleatfixedrate(timertask task,date firsttime,long period); // 在指定的延迟后开始进行重复的固定速率执行任务 scheduleatfixedrate(timertask task,long delay,long period); // 终止此计时器，丢弃所有当前已安排的任务。 cancal()； // 从此计时器的任务队列中移除所有已取消的任务。 purge()；
import java.util.timer;
import java.util.timertask;
public class timerexample {
public static void main(string[] args) {
timertask task = new timertask() {
@override
public void run() {
system.out.println("task executed at: " + system.currenttimemillis());
}
};
timer timer = new timer();
// 安排任务在1秒后执行，并且每隔1秒执行一次
timer.scheduleatfixedrate(task, 1000, 1000);
}
}
在这个示例中，我们创建了一个timer对象，并用scheduleatfixedrate方法安排一个timertask在1秒后开始执行，并且每隔1秒执行一次。
timer 优缺点分析
优点：jdk自带的，简单易用。
缺点：
（1）对系统时间敏感
timer类的任务调度是基于绝对时间的，而不是相对时间，所以它对系统时间的改变非常敏感。当系统时间发生变化时，可能导致任务执行时间的误差。
（2）不适合高并发场景
由于timer类使用单个线程执行所有任务，不适合在高并发环境下使用。当任务过多或任务执行时间较长时，会影响整体性能和响应性。
（3）任务的无法持久化
当应用程序关闭或重启时，timer 中已经调度的任务会丢失。
（4）单线程执行
timer类内部使用单个线程来执行所有的定时任务。如果某个任务执行时间过长，会影响其他任务的执行，可能导致任务被延迟。
当一个任务的执行时间过长时，会影响其他任务的调度。
import java.text.simpledateformat;
import java.util.date;
import java.util.timer;
import java.util.timertask;
import java.util.concurrent.timeunit;
/**
* @author water
* @date 2024/10/5
*/
public class main {
public static void main(string[] args) {
// 定时任务1
timertask timertask = new timertask() {
@override
public void run() {
simpledateformat sdf = new simpledateformat("hh:mm:ss.sss");
string datestr = sdf.format(new date());
system.out.println("进入定时任务1：" + datestr);
// 休眠5秒
try {timeunit.seconds.sleep(5);}
catch (interruptedexception e) {e.printstacktrace();}
datestr = sdf.format(new date());
system.out.println("运行定时任务1：" + datestr);
}
};
// 定时任务2
timertask timertask2 = new timertask() {
@override
public void run() {
simpledateformat sdf = new simpledateformat("hh:mm:ss.sss");
string datestr = sdf.format(new date());
system.out.println("-----进入定时任务2：" + datestr);
datestr = sdf.format(new date());
system.out.println("-----运行定时任务2：" + datestr);
}
};
// 计时器
timer timer = new timer();
// 添加执行任务（延迟 1s 执行，每 2s 执行一次）
timer.schedule(timertask, 1000, 2000);
timer.schedule(timertask2, 1000, 2000);
}
}
这段代码展示了如何使用java的timer和timertask类来实现定时任务的调度。以下是对代码的分析：
将timertask安排在延迟1秒后执行，随后每2秒执行一次。 将timertask2也安排在延迟1秒后执行，随后每2秒执行一次。
定时任务1第一次运行时会在1秒后进入并输出时间。由于在run()方法中调用了sleep(3)，这意味着此任务在执行期间会阻塞3秒。这会导致timertask的后续执行被延迟。
定时任务2将在1秒后运行，并每2秒执行一次，但由于定时任务1在运行时阻塞了线程，可能会影响任务2的执行频率。
代码的执行结果如下，
任务调度的具体过程：
- 刚开始主程序启动。
- 在时间是22:14:23.108时，任务1
timertask第一次执行，打印“进入定时任务1”字符串。任务2也被调度开始执行，但由于是单线程，任务2必须等待任务1完成。 - 在时间22:14:23.108到22:14:28.115时，任务1继续执行， 并休眠5秒，打印“运行定时任务1”字符串。此时任务2还是处于等待状态。
- 在时间是22:14:28.115时，任务1完成。然后此时任务2就开始执行，打印“进入定时任务2”和“运行定时任务2”字符串。
- 在时间是22:14:28.116时，因为初始的执行间隔为2秒，所以任务1再次被调度，打印“进入定时任务1”字符串。但由于被调度再次执行的任务1仍在执行，任务2再次处于等待状态。
- 在时间是22:14:28.116到22:14:33.110时，任务1继续执行， 并休眠5秒，打印“运行定时任务1”字符串。
- .....
当任务 1 运行时间超过设定的间隔时间时，任务 2 也会延迟执行。 原本任务 1 和任务 2 的执行时间间隔都是 2s，但因为任务 1 执行了 5s，因此任务 2 的执行时间间隔也变成了10秒（和原定时间不符）。
（5）错误处理能力有限
timer线程是不会捕获异常的，如果timertask抛出的了未检查异常则会导致timer线程终止，同时timer也不会重新恢复线程的执行，它会错误的认为整个timer线程都会取消。同时，已经被安排单尚未执行的timertask也不会再执行了，新的任务也不能被调度。因此如果timertask抛出未检查的异常，timer将会产生无法预料的行为。
（6）任务异常影响其他任务
使用 timer 类实现定时任务时，当一个任务抛出异常，其他任务也会终止运行。
timer线程是不会捕获异常的，如果timertask抛出的了未检查异常则会导致timer线程终止，同时timer也不会重新恢复线程的执行，它会错误的认为整个timer线程都会取消。同时，已经被安排单尚未执行的timertask也不会再执行了，新的任务也不能被调度。
import java.text.simpledateformat;
import java.util.date;
import java.util.timer;
import java.util.timertask;
/**
* @author water
* @date 2024/10/5
*/
public class main {
public static void main(string[] args) {
// 定时任务1
timertask timertask = new timertask() {
@override
public void run() {
simpledateformat sdf = new simpledateformat("hh:mm:ss.sss");
string datestr = sdf.format(new date());
system.out.println("进入定时任务1：" + datestr);
//发生异常
int num = 10 / 0;
datestr = sdf.format(new date());
system.out.println("运行定时任务1：" + datestr);
}
};
// 定时任务2
timertask timertask2 = new timertask() {
@override
public void run() {
simpledateformat sdf = new simpledateformat("hh:mm:ss.sss");
string datestr = sdf.format(new date());
system.out.println("----进入定时任务2：" + datestr);
datestr = sdf.format(new date());
system.out.println("----运行定时任务2：" + datestr);
}
};
// 计时器
timer timer = new timer();
// 添加执行任务（延迟 1s 执行，每 2s 执行一次）
timer.schedule(timertask, 1000, 2000);
timer.schedule(timertask2, 1000, 2000);
}
}
代码的执行结果如下，
3. 使用jdk自带的scheduledexecutorservice
scheduledexecutorservice是java并发包（java.util.concurrent）中的一个接口， 是java 1.5后新增的定时任务接口，它是基于线程池设计的定时任务类，每个调度任务都会分配到线程池中的一个线程去执行（任务是并发执行，互不影响）。
scheduledexecutorservice可以实现timer具备的所有功能，并解决了 timer类存在的问题提供了比timer更强大的定时任务调度功能。它可以调度任务在给定的延迟后运行，或者周期性地执行。
注意：只有当执行调度任务时，scheduledexecutorservice才会真正启动一个线程，其余时间scheduledexecutorservice都是出于轮询任务的状态。
import java.text.simpledateformat;
import java.util.date;
import java.util.concurrent.executors;
import java.util.concurrent.scheduledexecutorservice;
import java.util.concurrent.timeunit;
/**
* @author water
* @date 2024/10/5
*/
public class main {
public static void main(string[] args) {
scheduledexecutorservice scheduler = executors.newscheduledthreadpool(1);
runnable task = new runnable() {
@override
public void run() {
string datetime = new simpledateformat("yyyy-mm-dd hh:mm:ss").format(new date());
system.out.println("执行任务的时间：" + datetime);
}
};
// 安排任务在1秒后执行，并且每隔1秒执行一次
scheduler.scheduleatfixedrate(task, 1, 1, timeunit.seconds);
}
}
在这个示例中，我们创建了一个scheduledexecutorservice对象，并用scheduleatfixedrate方法安排一个任务在1秒后开始执行，并且每隔1秒执行一次。
schedule和scheduleatfixedrate的区别
在了解schedule与scheduleatfixedrate方法的区别之前，先看看它们的相同点：
任务执行未超时，下次执行时间 = 上次执行开始时间 + period。
任务执行超时，下次执行时间 = 上次执行结束时间。
在任务执行未超时时，它们都是上次执行时间加上间隔时间，来执行下一次任务。而执行超时时，都是立马执行。
它们的不同点在于侧重点不同
- schedule方法侧重保持间隔时间的稳定。
- scheduleatfixedrate方法更加侧重于保持执行频率的稳定。
schedule侧重保持间隔时间的稳定
schedule是固定延迟，更加侧重保持延迟间隔的固定性。每次都是以上一个任务的起始时间来判断时间间隔。
schedule方法会因为前一个任务的延迟而导致其后面的定时任务延时。计算公式为scheduledexecutiontime(第n+1次) = realexecutiontime(第n次) + periodtime。
也就是说如果第n次执行task时，由于某种原因这次执行时间过长，执行完后的systemcurrenttime>= scheduledexecutiontime(第n+1次)，则此时不做时隔等待，立即执行第n+1次task。
而接下来的第n+2次task的scheduledexecutiontime(第n+2次)就随着变成了realexecutiontime(第n+1次)+periodtime。这个方法更注重保持间隔时间的稳定。
// 延迟1s后开始执行任务，然后每隔2秒执行 timer.schedule(task, 1000, 2000);
- 第0~1秒，等待状态；
- 第1秒，第一个任务开始执行，执行耗时3秒；
- 计算第二个任务的预定执行时间：第一个任务的起始执行时间 + 任务执行周期两秒钟 = 1+2=3，所以第3秒是第二个任务的预定执行时间；
- 第4秒，第一个任务执行完毕，但是发现当前时间已经超过了第二个任务的预定执行时间，所以第二个任务立即执行，第二个任务的执行时间是1秒钟；
- 计算第三个任务的预定执行时间：第二个任务起始执行时间+任务执行周期两秒钟=4+2=6，所以第三个任务是预定在第6秒执行；
- 第5秒钟，第二个任务执行完毕，发现当前是第5秒，还未到第6秒，所以还需要等待1秒钟。
scheduleatfixedrate保持执行频率的稳定
scheduleatfixedrate是固定速率，更加侧重保持执行频率的稳定性。scheduleatfixedrate当前任务到达规定时间一定执行，上一个未执行的任务会直接终止。
scheduleatfixedrate在反复执行一个task的计划时，每一次执行这个task的计划执行时间在最初就被定下来了，也就是scheduledexecutiontime(第n次)=firstexecutetime +n*periodtime。
如果第n次执行task时，由于某种原因这次执行时间过长，执行完后的systemcurrenttime>= scheduledexecutiontime(第n+1次)，则此时不做period间隔等待，立即执行第n+1次task。
接下来的第n+2次的task的scheduledexecutiontime(第n+2次)依然还是firstexecutetime+（n+2)*periodtime这在第一次执行task就定下来了。说白了，这个方法更注重保持执行频率的稳定。
如果用一句话来描述任务执行超时之后schedule和scheduleatfixedrate的区别就是：schedule的策略是错过了就错过了，后续按照新的节奏来走；scheduleatfixedrate的策略是如果错过了，就努力追上原来的节奏（制定好的节奏）。
简而言之：schedule的策略是错过了就错过了，后续按照新的节奏来走；scheduleatfixedrate的策略是如果错过了，就努力追上原来的节奏。
4. 使用springtask实现定时任务
从spring 3开始，spring自带了一套定时任务工具spring-task（基于注解 @scheduled，@enablescheduling 形式实现），可以把它看成是一个轻量级的quartz，使用起来十分简单，除spring相关的包外不需要额外的包，支持注解和配置文件两种形式。通常情况下在spring体系内，针对简单的定时任务，可直接使用spring提供的功能。
如果你在使用spring框架，可以利用@scheduled注解来方便地实现定时任务。首先，需要确保你的spring配置中启用了任务调度功能。如果是在spring boot项目中，需要在启动类上添加@enablescheduling来开启定时任务。
以 spring boot 为例，实现定时任务只需两步：
- 开启定时任务
- 添加定时任务
（1）开启定时任务
如果是在spring boot项目中，需要在启动类上添加@enablescheduling来开启定时任务
@enablescheduling // 开启定时任务
@springbootapplication
public class job4scheduledapplication {
public static void main(string[] args) {
springapplication.run(job4scheduledapplication.class, args);
}
}（2）添加定时任务
定时任务的添加只需要使用 @scheduled 注解标注即可，如果有多个定时任务可以创建多个 @scheduled 注解标注的方法。
@component //@component用于实例化类，将其类托管给 spring 容器
public class taskjobutil {
/**
* cron表达式：表示每2秒 执行任务
*/
@scheduled(cron = "0/2 * * * * ?")
public void task() {
system.out.println("task0-start");
sleep(5);
system.out.println("task0-end");
}
/**
* fixedrate：每间隔2秒执行一次任务
* 注意，默认情况下定时任务是在同一线程同步执行的，如果任务的执行时间（如5秒）大于间隔时间，则会等待任务执行结束后直接开始下次任务
*/
@scheduled(fixedrate = 2000)
public void task0() {
system.out.println("task0-start");
sleep(5);
system.out.println("task0-end");
}
/**
* fixeddelay：每次延时2秒执行一次任务
* 注意，这里是等待上次任务执行结束后，再延时固定时间后开始下次任务
*/
@scheduled(fixeddelay = 2000)
public void task1() {
system.out.println("task1-start");
sleep(5);
system.out.println("task1-end");
}
/**
* initialdelay：首次任务启动的延时时间
*/
@scheduled(initialdelay = 2000, fixeddelay = 3000)
public void task2() {
system.out.println("task2-start");
sleep(5);
system.out.println("task2-end");
}
private void sleep(long time) {
try {
timeunit.seconds.sleep(time);
} catch (interruptedexception e) {
e.printstacktrace();
}
}
}三、分布式定时任务实现方式
前面所有的定时任务，无论是基于线程类，还是基于 jdk 自带的定时任务，还是基于spring提供的spring task，都无法在分布式环境下使用，并且不支持持久化，一旦服务重启所有的定时任务都将发生丢失，所以我们需要使用到其它的第三方成熟的定时任务框架。
1. quartz
除了jdk自带的api之外，我们还可以使用开源的框架来实现，比如quartz。quartz是一个开源的任务调度库，用于在java应用程序中实现定时任务调度和作业调度。，它允许开发者通过配置或编程方式定义、调度和管理任务。
使用quartz可以开发一个或者多个定时任务，每个定时任务可以单独指定执行的时间，例如每隔1小时执行一次、每个月第一天上午10点执行一次、每个月最后一天下午5点执行一次等。
quartz既可以单独使用也可以跟spring框架整合使用，在实际开发中一般会使用后者。
（1）quartz的核心功能包括：
- 任务调度：定义任务的执行计划，并在指定时间或周期性执行任务。
- 任务管理：管理和控制任务的生命周期，如启动、暂停、删除等。
- 持久化：支持将任务的状态持久化到数据库，以便在应用重启后恢复任务状态。
（2）quartz架构图如下：
quartz主要由以下几个核心组件组成：
- scheduler：调度器，是quartz的核心，用于管理和调度任务。
- job：任务接口，定义任务的执行逻辑，即具体要执行的任务。所有quartz任务必须实现这个接口。
- jobdetail：任务细节对象，定义了任务的具体实现和执行参数。
- trigger：触发器，定义了任务的触发条件，如时间、周期等。
- simpletrigger
- crontirgger：和 unix 的 cron 机制基本一样，基于通用的公历。
- dateintervaltrigger
- nthincludeddaytrigger
- jobdatamap：任务数据映射，用于传递任务执行时所需的数据。
jobdetail就是对job的定义，而job是具体执行的逻辑内容。 具体的执行的逻辑需要实现 job类，并实现execute方法。如果使用jobdetail来定义，那么每次调度都会创建一个new job实例，这样带来的好处就是任务并发执行的时候，互不干扰，不会对临界资源造成影响。
（3）quartz的使用步骤
使用quartz进行定时任务调度通常包括以下步骤：
- 创建任务类：实现job接口，定义任务的执行逻辑。
- 配置调度器：创建并配置scheduler实例。
- 定义任务细节：创建jobdetail对象，指定任务类及其参数。
- 定义触发器：创建trigger对象，指定任务的触发条件。
- 启动调度器：将任务细节和触发器注册到调度器，并启动调度器。
示例：使用quartz进行定时任务调度
以下是一个使用quartz进行定时任务调度的完整示例：
（1）创建任务类
在这个示例中，hellojob类实现了job接口，定义了任务的执行逻辑，即打印一条消息。
import org.quartz.job;
import org.quartz.jobexecutioncontext;
import org.quartz.jobexecutionexception;
public class hellojob implements job {
@override
public void execute(jobexecutioncontext context) throws jobexecutionexception {
system.out.println("hello, quartz!");
}
}
hellojob 类该类实现了 job 接口。实现了quartz 调度器调用的核心方法 execute 方法。
execute 方法的jobexecutioncontext context 参数允许作业访问调度上下文中的信息，如触发器、调度器等。在方法体内，使用 system.out.println("hello, quartz!"); 打印一条简单的消息，表示作业被执行。
（2）配置调度器
在这个示例中，我们创建了一个调度器，并定义了一个任务和一个触发器。任务hellojob每10秒执行一次，并在控制台上打印消息。
import org.quartz.jobbuilder;
import org.quartz.jobdetail;
import org.quartz.jobdatamap;
import org.quartz.jobkey;
import org.quartz.scheduler;
import org.quartz.schedulerexception;
import org.quartz.schedulerfactory;
import org.quartz.trigger;
import org.quartz.triggerbuilder;
import org.quartz.cronschedulebuilder;
import org.quartz.simpleschedulebuilder;
import org.quartz.jobbuilder;
import org.quartz.jobdetail;
import org.quartz.trigger;
import org.quartz.triggerbuilder;
import org.quartz.cronschedulebuilder;
import org.quartz.simpleschedulebuilder;
public class quartzexample {
public static void main(string[] args) {
try {
// 创建调度器工厂
schedulerfactory schedulerfactory = new org.quartz.impl.stdschedulerfactory();
scheduler scheduler = schedulerfactory.getscheduler();
// 定义任务细节
jobdetail jobdetail = jobbuilder.newjob(hellojob.class)
.withidentity("myjob", "group1")
.usingjobdata("key", "value") // 传递任务数据
.build();
// 定义触发器
trigger trigger = triggerbuilder.newtrigger()
.withidentity("mytrigger", "group1")
.startnow()
.withschedule(simpleschedulebuilder.simpleschedule()
.withintervalinseconds(10) // 每10秒执行一次
.repeatforever())
.build();
// 将任务细节和触发器注册到调度器
scheduler.schedulejob(jobdetail, trigger);
// 启动调度器
scheduler.start();
} catch (schedulerexception e) {
e.printstacktrace();
}
}
}
在这个示例中，我们创建一个调度器工厂的实例schedulerfactory，使用默认的标准调度器工厂。从调度器工厂获取一个调度器实例scheduler，用于安排和执行任务。
然后，创建一个新的任务细节，指定作业类为 hellojob。该类应该实现 org.quartz.job 接口。为任务指定唯一的标识符，名称为 "myjob"，组名为 "group1"。通过 jobdatamap 向任务传递参数，方便在作业执行时使用。构建最终的 jobdetail 对象。
创建一个新的触发器构建器实例，为触发器指定唯一的标识符，名称为 "mytrigger"，组名为 "group1"，设置触发器为立即开始执行。使用简单调度器定义触发规则：设置触发器每 10 秒执行一次，并且使触发器无限期重复执行。构建最终的 trigger 对象。
将任务和触发器注册到调度器中，使其能够根据触发器的调度规则执行任务。
启动调度器，使其开始调度任务。
（3）使用cron表达式
quartz支持使用cron表达式来定义更复杂的触发条件。cron表达式是一种字符串格式，用于表示任务的触发时间。以下是一个使用cron表达式的示例：
trigger crontrigger = triggerbuilder.newtrigger()
.withidentity("mycrontrigger", "group1")
.withschedule(cronschedulebuilder.cronschedule("0 0/5 * * * ?")) // 每5分钟执行一次
.build();
在这个示例中，创建了一个名为 "mycrontrigger" 的 cron 触发器，它每 5 分钟触发一次。cron表达式"0 0/5 * * * ?"表示任务将在每5分钟的开始时刻执行一次。
quartz的持久化
quartz支持将任务的状态持久化到数据库，以便在应用重启后恢复任务状态。要使用持久化功能，需要配置quartz的持久化存储。
（1）配置持久化存储
在quartz.properties文件中配置数据库连接和持久化存储，
org.quartz.jobstore.class = org.quartz.impl.jdbcjobstore.jobstoretx org.quartz.jobstore.driverdelegateclass = org.quartz.impl.jdbcjobstore.stdjdbcdelegate org.quartz.jobstore.datasource = myds org.quartz.jobstore.tableprefix = qrtz_ org.quartz.jobstore.isclustered = true
还需要配置数据源myds，以便quartz能够连接到数据库。
（2）数据库表
quartz提供了创建数据库表的sql脚本，可以在quartz官网下载。执行这些脚本将创建quartz所需的表。
2. xxl-job
xxl-job是一个轻量级分布式任务调度平台。特点是平台化，易部署，开发迅速、学习简单、轻量级、易扩展。由调度中心和执行器功能完成定时任务的执行。调度中心负责统一调度，执行器负责接收调度并执行。
3. elastic-job
elastic-job是一个开源的分布式任务调度解决方案，它是基于java的轻量级分布式调度框架。
比较
三者的比较
- 功能和特性：
- quartz：quartz是一个功能强大的作业调度框架，支持灵活的任务调度策略、分布式集群、任务持久化等特性。它具有丰富的api和扩展点，可以根据需求进行定制开发和扩展。
- xxl-job：xxl-job是一个分布式任务调度平台，提供了可视化操作界面、多种任务调度方式、分片任务支持等特性。它注重于任务的管理和监控，并提供了报警与告警功能。
- elastic-job：elastic-job是一个轻量级的分布式任务调度解决方案，支持分布式任务调度、弹性扩缩容、任务监控和管理等特性。它注重于任务的弹性扩展和容错机制。
- 分布式支持：
- quartz：quartz在分布式场景中需要基于数据库锁来保证操作的唯一性，通过多个节点的异步运行实现高可用性。但它没有执行层面的任务分片机制。
- xxl-job：xxl-job提供了分布式集群的支持，可以实现任务的负载均衡和高可用性。它支持分片任务和动态调整任务节点数量的特性。
- elastic-job：elastic-job支持分布式任务调度，具备弹性扩缩容能力，可以根据任务的执行情况动态调整任务节点数量。
- 可视化和管理界面：
- quartz：quartz本身没有提供可视化的任务管理界面，需要通过其他工具或自行开发来实现。
- xxl-job：xxl-job提供了简洁直观的任务管理界面，方便用户进行任务的创建、编辑、状态查看等操作。
- elastic-job：elastic-job提供了任务监控和管理功能，可以查看任务的执行日志、运行状态、统计信息等。
- 社区活跃度和生态系统：
- quartz：quartz是一个非常成熟且广泛使用的作业调度框架，拥有强大的社区支持和丰富的生态系统。
- xxl-job：xxl-job也有一个活跃的社区，并且在国内得到广泛应用和认可。
- elastic-job：elastic-job相对较新，并且社区规模较小，但其在分布式任务调度领域有一定的影响力。
- 应用场景：
- quartz在功能和扩展性上非常强大，适用于复杂的任务调度需求。
- xxl-job注重于任务管理和监控，并提供了可视化的操作界面。
- elastic-job轻量级且具备分布式任务调度和弹性扩缩容能力。
四、总结
（1）线程+休眠实现定时任务，是最简单实现定时任务的方式了，但这只是提供一种思路，实习开发中几乎不会使用。
（2）jdk自带的定时任务timer和scheduledexecutorservice，我们需要了解两者的区别。
- timer是单线程的，一旦发生异常，将终止所有的任务；timer是绝对时间的，会受到系统时间的影响。
- scheduledexecutorservice是基于线程池，是多线程的，一旦发生异常，不会终止所有的任务；scheduledexecutorservice是相对时间 ，不会受到系统时间的影响。
- 注意区固定间隔和固定频率的区别。
（3）spring task实现的定时任务是基于线程池，是多线程的，一旦发生异常，不会终止所有的任务；基于相对时间，不会受到系统时间的影响。
（4）分布式定时任务，一般是直接使用第三方成熟的定时任务框架，当然如果你公司资金充足可以选择开发定制化定时任务框架。选用开源的第三方成熟定时任务框架，好处在于功能完善、免费，代码质量也是有保障的。
如果你当前系统比较小，或者说没那么在意可靠性，可以选用 jdk自带的定时任务或者是springtask，否则就选用分布式定时任务框架，轻量级就可以选用 xxl-job，大型系统可以选用quartz。
到此这篇关于java中实现定时任务的两种方法的文章就介绍到这了,更多相关java实现定时任务内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论