ein Hintergrund
Das Projekt benötigt eine Funktion, die zeitgesteuerte Aufgaben dynamisch hinzufügen kann. Jetzt verwendet das Projekt das zeitgesteuerte Aufgabenplanungssystem von xxl-job, aber nach einigem Verständnis der Funktion von xxl-job stellt sich heraus, dass xxl-job dem Projekt dynamisch Zeit hinzufügt .-Aufgaben ist die Unterstützung für das dynamische Löschen von zeitgesteuerten Aufgaben nicht so gut, sodass Sie die Funktion einer zeitgesteuerten Aufgabe selbst manuell implementieren müssen
Zwei dynamische Timing-Task-Scheduling
1 Technologieauswahl
TimeroderScheduledExecutorService
Beide können die zeitliche Aufgabenplanung realisieren.Sehen wir uns zunächst die zeitliche Aufgabenplanung von Timer an.
public class MyTimerTask extends TimerTask {
private String name;
public MyTimerTask(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public void run() {
//task
Calendar instance = Calendar.getInstance();
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(instance.getTime()));
}
}
Timer timer = new Timer();
MyTimerTask timerTask = new MyTimerTask("NO.1");
//首次执行,在当前时间的1秒以后,之后每隔两秒钟执行一次
timer.schedule(timerTask,1000L,2000L);
复制代码Sehen Sie sich die Implementierung von ScheduledThreadPoolExecutor an
//org.apache.commons.lang3.concurrent.BasicThreadFactory
ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(1,
new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").daemon(true).build());
executorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
//do something
}
},initialDelay,period, TimeUnit.HOURS);
复制代码Beide können zeitgesteuerte Aufgaben implementieren, also was ist der Unterschied zwischen ihnen, die Verwendung von Ali p3c wird Vorschläge und Unterschiede geben
多线程并行处理定时任务时，Timer运行多个TimeTask时，只要其中之一没有捕获抛出的异常，其它任务便会自动终止运行，使用ScheduledExecutorService则没有这个问题。
复制代码Aus Sicht der Vorschläge müssen wir wählen ScheduledExecutorService, schauen wir uns den Quellcode an, um zu sehen, warum Timerdie Ausführung abgebrochen wird, wenn es ein Problem gibt
/**
* The timer thread.
*/
private final TimerThread thread = new TimerThread(queue);
public Timer() {
this("Timer-" + serialNumber());
}
public Timer(String name) {
thread.setName(name);
thread.start();
}
复制代码Wenn wir ein neues Objekt erstellen, sehen wir, dass ein Thread gestartet wird. Was macht dieser Thread also? Lass uns mal sehen
class TimerThread extends Thread {
boolean newTasksMayBeScheduled = true;
/**
* 每一件一个任务都是一个quene
*/
private TaskQueue queue;
TimerThread(TaskQueue queue) {
this.queue = queue;
}
public void run() {
try {
mainLoop();
} finally {
// Someone killed this Thread, behave as if Timer cancelled
synchronized(queue) {
newTasksMayBeScheduled = false;
queue.clear(); // 清除所有任务信息
}
}
}
/**
* The main timer loop. (See class comment.)
*/
private void mainLoop() {
while (true) {
try {
TimerTask task;
boolean taskFired;
synchronized(queue) {
// Wait for queue to become non-empty
while (queue.isEmpty() && newTasksMayBeScheduled)
queue.wait();
if (queue.isEmpty())
break; // Queue is empty and will forever remain; die
// Queue nonempty; look at first evt and do the right thing
long currentTime, executionTime;
task = queue.getMin();
synchronized(task.lock) {
if (task.state == TimerTask.CANCELLED) {
queue.removeMin();
continue; // No action required, poll queue again
}
currentTime = System.currentTimeMillis();
executionTime = task.nextExecutionTime;
if (taskFired = (executionTime<=currentTime)) {
if (task.period == 0) { // Non-repeating, remove
queue.removeMin();
task.state = TimerTask.EXECUTED;
} else { // Repeating task, reschedule
queue.rescheduleMin(
task.period<0 ? currentTime - task.period
: executionTime + task.period);
}
}
}
if (!taskFired) // Task hasn't yet fired; wait
queue.wait(executionTime - currentTime);
}
if (taskFired) // Task fired; run it, holding no locks
task.run();
} catch(InterruptedException e) {
}
}
}
}
复制代码Wir sehen, dass, ausgeführt mainLoop(), es eine Endlosschleife der while (true)Methode gibt, und die Zeit im Task-Objekt im Programm mit der aktuellen Zeit verglichen wird, und dasselbe wird ausgeführt, aber sobald ein Fehler gemeldet wird, wird es endgültig zu Löschen Sie alle Aufgabeninformationen.
Zu diesem Zeitpunkt haben wir die Antwort gefunden. Nachdem der Timer instanziiert wurde, startet er einen Thread und führt einen ununterbrochenen Schleifenabgleich durch, um Aufgaben auszuführen. Es ist ein Single-Thread. Sobald ein Fehler gemeldet wird, wird der Thread beendet, also wird er es nicht tun nachfolgenden Task ausführen, und ScheduledThreadPoolExecutor wird von mehreren Threads ausgeführt, selbst wenn einer der Tasks einen Fehler meldet, wirkt sich dies nicht auf die Ausführung anderer Threads aus.
2 Verwenden von ScheduledThreadPoolExecutor
Aus dem oben Gesagten ScheduledThreadPoolExecutorist die Verwendung relativ einfach, aber wir wollen es eleganter erreichen, also wählen Sie es aus, um es TaskSchedulerzu erreichen
@Component
public class CronTaskRegistrar implements DisposableBean {
private final Map<Runnable, ScheduledTask> scheduledTasks = new ConcurrentHashMap<>(16);
@Autowired
private TaskScheduler taskScheduler;
public TaskScheduler getScheduler() {
return this.taskScheduler;
}
public void addCronTask(Runnable task, String cronExpression) {
addCronTask(new CronTask(task, cronExpression));
}
private void addCronTask(CronTask cronTask) {
if (cronTask != null) {
Runnable task = cronTask.getRunnable();
if (this.scheduledTasks.containsKey(task)) {
removeCronTask(task);
}
this.scheduledTasks.put(task, scheduleCronTask(cronTask));
}
}
public void removeCronTask(Runnable task) {
Set<Runnable> runnables = this.scheduledTasks.keySet();
Iterator it1 = runnables.iterator();
while (it1.hasNext()) {
SchedulingRunnable schedulingRunnable = (SchedulingRunnable) it1.next();
Long taskId = schedulingRunnable.getTaskId();
SchedulingRunnable cancelRunnable = (SchedulingRunnable) task;
if (taskId.equals(cancelRunnable.getTaskId())) {
ScheduledTask scheduledTask = this.scheduledTasks.remove(schedulingRunnable);
if (scheduledTask != null){
scheduledTask.cancel();
}
}
}
}
public ScheduledTask scheduleCronTask(CronTask cronTask) {
ScheduledTask scheduledTask = new ScheduledTask();
scheduledTask.future = this.taskScheduler.schedule(cronTask.getRunnable(), cronTask.getTrigger());
return scheduledTask;
}
@Override
public void destroy() throws Exception {
for (ScheduledTask task : this.scheduledTasks.values()) {
task.cancel();
}
this.scheduledTasks.clear();
}
}
复制代码TaskSchedulerEs ist die Kernklasse dieser Funktionsimplementierung, aber es ist eine Schnittstelle
public interface TaskScheduler {
/**
* Schedule the given {@link Runnable}, invoking it whenever the trigger
* indicates a next execution time.
* <p>Execution will end once the scheduler shuts down or the returned
* {@link ScheduledFuture} gets cancelled.
* @param task the Runnable to execute whenever the trigger fires
* @param trigger an implementation of the {@link Trigger} interface,
* e.g. a {@link org.springframework.scheduling.support.CronTrigger} object
* wrapping a cron expression
* @return a {@link ScheduledFuture} representing pending completion of the task,
* or {@code null} if the given Trigger object never fires (i.e. returns
* {@code null} from {@link Trigger#nextExecutionTime})
* @throws org.springframework.core.task.TaskRejectedException if the given task was not accepted
* for internal reasons (e.g. a pool overload handling policy or a pool shutdown in progress)
* @see org.springframework.scheduling.support.CronTrigger
*/
@Nullable
ScheduledFuture<?> schedule(Runnable task, Trigger trigger);
复制代码Wie Sie dem vorherigen Code entnehmen können, haben wir diese Klasse in die Klasse eingefügt, aber es handelt sich um eine Schnittstelle. Woher wissen wir, um welche Implementierungsklasse es sich handelt? In der Vergangenheit mussten wir in diesem Fall @Prmany oder @Quality hinzufügen an die Klasse, um die implementierte Klasse auszuführen. , aber wir sehen, dass meine Injektion nicht markiert ist, weil sie auf andere Weise implementiert ist
@Configuration
public class SchedulingConfig {
@Bean
public TaskScheduler taskScheduler() {
ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
// 定时任务执行线程池核心线程数
taskScheduler.setPoolSize(4);
taskScheduler.setRemoveOnCancelPolicy(true);
taskScheduler.setThreadNamePrefix("TaskSchedulerThreadPool-");
return taskScheduler;
}
}
复制代码在spring初始化时就注册了Bean TaskScheduler，而我们可以看到他的实现是ThreadPoolTaskScheduler，在网上的资料中有人说ThreadPoolTaskScheduler是TaskScheduler的默认实现类，其实不是，还是需要我们去指定，而这种方式，当我们想替换实现时，只需要修改配置类就行了，很灵活。
而为什么说他是更优雅的实现方式呢，因为他的核心也是通过ScheduledThreadPoolExecutor来实现的
public ScheduledExecutorService getScheduledExecutor() throws IllegalStateException {
Assert.state(this.scheduledExecutor != null, "ThreadPoolTaskScheduler not initialized");
return this.scheduledExecutor;
}
复制代码三 多节点任务执行问题
这次的实现过程中，我并没有选择xxl-job来进行实现，而是采用了TaskScheduler来实现，这也产生了一个问题，xxl-job是分布式的程序调度系统，当想要执行定时任务的应用使用xxl-job时，无论应用程序中部署多少个节点，xxl-job只会选择其中一个节点作为定时任务执行的节点，从而不会产生定时任务在不同节点上同时执行，导致重复执行问题，而使用TaskScheduler来实现，就要考虑多节点重复执行问题。当然既然有问题，就有解决方案
· 方案一 将定时任务功能拆出来单独部署，且只部署一个节点 · 方案二 使用redis setNx的形式，保证同一时间只有一个任务在执行
我选择的是方案二来执行，当然还有一些方式也能保证不重复执行，这里就不多说了，一下是我的实现
public void executeTask(Long taskId) {
if (!redisService.setIfAbsent(String.valueOf(taskId),"1",2L, TimeUnit.SECONDS)) {
log.info("已有执行中定时发送短信任务，本次不执行！");
return;
}
复制代码四 后记
其实定时任务应该每一个开发都会用到的工具，以前并没有了解其中的实现，这次的功能开发过程中也算是对其内涵的进一步了解，以后遇到定时任务的处理也更清晰，更有效率了。