Bagaimana untuk melaksanakan fungsi tugas berjadual SpringBoot

Latar Belakang

Projek memerlukan fungsi yang boleh menambah tugas berjadual secara dinamik Sistem penjadualan tugas berjadual xxl-job sedang digunakan dalam projek, tetapi selepas beberapa pemahaman tentang fungsi xxl-job , saya dapati. bahawa sokongan xxl-job untuk menambahkan tugas berjadual secara dinamik dan memadam tugas berjadual secara dinamik pada projek itu tidak begitu baik, jadi saya perlu melaksanakan fungsi tugas berjadual secara manual

Penjadualan tugas berjadual dinamik kedua

1 Pilihan Teknologi

Timer atau ScheduledExecutorService

Kedua -duanya boleh melaksanakan penjadualan tugas yang dijadualkan.

  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);

Mari kita lihat pelaksanaan ScheduledThreadPoolExecutor

//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);

Kedua-duanya boleh melaksanakan tugas berjadual, jadi apakah perbezaan mereka menggunakan Alibaba p3c akan memberikan cadangan dan perbezaan

多线程并行处理定时任务时，Timer运行多个TimeTask时，只要其中之一没有捕获抛出的异常，其它任务便会自动终止运行，使用ScheduledExecutorService则没有这个问题。

Daripada cadangan? Lihat, anda mesti memilih

Mari kita lihat kod sumber untuk melihat mengapa ScheduledExecutorService akan menamatkan pelaksanaan jika terdapat masalah dimulakan, jadi benang ini sedang melakukan Apa? Mari kita lihat Timer

/**
 * The timer thread.
 */
private final TimerThread thread = new TimerThread(queue);
public Timer() {
    this("Timer-" + serialNumber());
}
public Timer(String name) {
    thread.setName(name);
    thread.start();
}

Kami melihat bahawa apabila

dilaksanakan, kaedah

bergelung tanpa had untuk mendapatkan masa dalam objek tugasan dalam program dan membandingkannya dengan masa semasa ia adalah sama, ia akan dilaksanakan, tetapi apabila ralat dilaporkan, ia akan memasuki akhirnya dan mengosongkan semua maklumat tugas.

mainLoop()Pada masa ini kami telah menemui jawapannya Selepas pemasa dimulakan, ia memulakan urutan dan melaksanakan tugasan dalam padanan gelung tanpa gangguan. Setelah ralat dilaporkan, utas itu ditamatkan . Oleh itu, tugasan berikutnya tidak akan dilaksanakan dan ScheduledThreadPoolExecutor dilaksanakan oleh berbilang utas Walaupun salah satu tugasan melaporkan ralat, ia tidak akan menjejaskan pelaksanaan utas lain. while (true)

2 Menggunakan ScheduledThreadPoolExecutor

Daripada perkara di atas, ia agak mudah digunakan , tetapi kami ingin melaksanakannya dengan lebih elegan, jadi kami memilih

untuk melaksanakannya.

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&#39;t yet fired; wait
                      queue.wait(executionTime - currentTime);
              }
              if (taskFired)  // Task fired; run it, holding no locks
                  task.run();
          } catch(InterruptedException e) {
          }
      }
  }
}

ScheduledThreadPoolExecutorTaskScheduler ialah kelas teras untuk pelaksanaan fungsi ini, tetapi ia adalah antara muka

@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();
    }
}

Seperti yang anda boleh lihat daripada kod sebelumnya, kami menyuntik kelas ini ke dalam kelas, tetapi ia adalah Antara Muka, bagaimana kita tahu kelas pelaksanaan yang mana pada masa lalu, apabila ini berlaku, kita perlu menambah @Primany atau @Quality ke kelas untuk melaksanakan kelas yang dilaksanakan, tetapi kita melihat bahawa tiada kelas? tandakan pada suntikan saya kerana ia melalui satu lagi TaskScheduler

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);

yang dilaksanakan dengan cara ini mendaftarkan Bean TaskScheduler semasa permulaan musim bunga, dan kita dapat melihat bahawa pelaksanaannya ialah ThreadPoolTaskScheduler Dalam maklumat dalam talian, sesetengah orang mengatakan bahawa ThreadPoolTaskScheduler adalah kelas pelaksanaan lalai TaskScheduler Sebenarnya, ia tidak, atau Kami perlu menentukan, dan dengan cara ini, apabila kami ingin menggantikan pelaksanaan, kami hanya perlu mengubah suai kelas konfigurasi, yang sangat fleksibel.

Dan mengapa ia dikatakan sebagai pelaksanaan yang lebih elegan kerana terasnya juga dilaksanakan melalui ScheduledThreadPoolExecutor

@Configuration
public class SchedulingConfig {
    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        // 定时任务执行线程池核心线程数
        taskScheduler.setPoolSize(4);
        taskScheduler.setRemoveOnCancelPolicy(true);
        taskScheduler.setThreadNamePrefix("TaskSchedulerThreadPool-");
        return taskScheduler;
    }
}

Tiga isu pelaksanaan tugas berbilang nod

Kali ini Semasa tempoh proses pelaksanaan, saya tidak memilih xxl-job untuk pelaksanaan, tetapi menggunakan TaskScheduler untuk pelaksanaan Ini juga menyebabkan masalah xxl-job ialah sistem penjadualan program yang diedarkan, yang digunakan apabila aplikasi ingin melaksanakan tugas yang dijadualkan digunakan, tidak kira berapa banyak nod yang digunakan dalam aplikasi, xxl-job hanya akan memilih salah satu nod sebagai nod untuk pelaksanaan tugas berjadual, supaya tugas berjadual tidak akan dilaksanakan serentak pada nod yang berbeza, mengakibatkan masalah pelaksanaan berulang . Sebaliknya, gunakan Untuk melaksanakan TaskScheduler, kita mesti mempertimbangkan isu pelaksanaan berulang pada berbilang nod. Sudah tentu, kerana terdapat masalah, terdapat penyelesaian

· Solution 1 memisahkan fungsi tugasan yang dijadualkan dan mengaturnya secara berasingan, dan hanya menggunakan satu nod· sedang berjalan pada masa yang sama Pelaksanaan

Saya memilih pilihan kedua untuk melaksanakan Sudah tentu, terdapat beberapa cara untuk memastikan ia tidak dilaksanakan berulang kali

rreeee

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan fungsi tugas berjadual SpringBoot. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!