Comment implémenter des tâches planifiées dans un environnement autonome Java

Cadre de tâches chronométrées

TimeTask

Depuis que nous avons commencé à apprendre Java, TimeTask a été utilisé pour la première fois pour implémenter des tâches planifiées. Timer utilise en interne la classe TaskQueue pour stocker les tâches planifiées. .file d'attente de niveau. TaskQueue triera les tâches en fonction de la distance entre les tâches et de la prochaine heure d'exécution, en veillant à ce que les tâches en haut du tas soient exécutées en premier.

Exemple de code :

 public static void main(String[] args)
    {
          TimerTask task = new TimerTask() {
              public void run() {
                  System.out.println("当前时间: " + new Date() + "n" +
                          "线程名称: " + Thread.currentThread().getName());
              }
          };
          Timer timer = new Timer("Timer");
          long delay = 5000L;
          timer.schedule(task, delay);
          System.out.println("当前时间: " + new Date() + "n" +
                  "线程名称: " + Thread.currentThread().getName());
    }

Résultat d'exécution :

当前时间: Wed Apr 06 22:05:04 CST 2022n线程名称: main
当前时间: Wed Apr 06 22:05:09 CST 2022n线程名称: Timer

Comme le montrent les résultats, la tâche planifiée a été exécutée après 5 secondes.

Inconvénients :

• Les tâches d'exécution de TimeTask ne peuvent être exécutées qu'en série. Une fois qu'une tâche prend beaucoup de temps à s'exécuter, cela affectera l'exécution d'autres tâches

• Si une exception se produit lors de l'exécution de la tâche, le la tâche s'arrêtera directement.

Au fil du temps, la technologie Java est constamment mise à jour. En réponse aux lacunes de TimeTask, ScheduledExecutorService semble remplacer TimeTask.

ScheduledExecutorService

ScheduledExecutorService est une interface avec plusieurs classes d'implémentation. La plus couramment utilisée est ScheduledThreadPoolExecutor. Le ScheduledThreadPoolExecutor lui-même est un pool de threads, qui utilise DelayQueue en interne comme file d'attente de tâches et prend en charge l'exécution simultanée de tâches.

Exemple de code :

 public static void main(String[] args) throws InterruptedException
   {
      ScheduledExecutorService executorService =
              Executors.newScheduledThreadPool(3);
      // 执行任务: 每 10秒执行一次
      executorService.scheduleAtFixedRate(() -> {
          System.out.println("执行任务：" + new Date()+",线程名称: " + Thread.currentThread().getName());
      }, 1, 10, TimeUnit.SECONDS);
    }

Inconvénients :

• Essayez d'éviter d'utiliser des exécuteurs pour créer un pool de threads, car la file d'attente utilisée en interne dans le pool de threads de jdk est relativement grande et un MOO est susceptible de se produire. .

• Les tâches planifiées sont basées sur la mémoire autonome de la JVM. Une fois la tâche planifiée redémarrée, elle disparaîtra.

• ne peut pas prendre en charge les expressions cron pour implémenter des tâches planifiées riches.

Spring Task

Après avoir appris Spring, j'ai commencé à utiliser la propre Task de Spring. Spring Framework est livré avec des tâches planifiées et fournit des expressions cron pour implémenter de riches configurations de tâches planifiées.

Exemple de code :

@EnableScheduling
@Component
public class SpringTask
{
    private Logger logger = LoggerFactory.getLogger(SpringTask.class);
    private static final SimpleDateFormat dateFormat = new SimpleDateFormat(
            "HH:mm:ss");
    /**
     * fixedRate：固定速率执行。每5秒执行一次。
     */
    @Scheduled(fixedRate = 5000)
    public void invokeTaskWithFixedRate()
    {
        logger.info("Fixed Rate Task :  Current Time  is  {}",
                dateFormat.format(new Date()));
    }
    /**
     * fixedDelay：固定延迟执行。距离上一次调用成功后2秒才执。
     */
    @Scheduled(fixedDelay = 2000)
    public void invokeTaskWithFixedDelay()
    {
        try
        {
            TimeUnit.SECONDS.sleep(3);
            logger.info("Fixed Delay Task : Current Time  is  {}",
                    dateFormat.format(new Date()));
        }
        catch (InterruptedException e)
        {
            logger.error("invoke task error",e);
        }
    }
    /**
     * initialDelay:初始延迟。任务的第一次执行将延迟5秒，然后将以5秒的固定间隔执行。
     */
    @Scheduled(initialDelay = 5000, fixedRate = 5000)
    public void invokeTaskWithInitialDelay()
    {
        logger.info("Task with Initial Delay : Current Time is  {}",
                dateFormat.format(new Date()));
    }
    /**
     * cron：使用Cron表达式,每隔5秒执行一次
     */
    @Scheduled(cron = "0/5 * * * * ? ")
    public void invokeTaskWithCronExpression()
    {
        logger.info("Task Cron Expression:  Current Time  is  {}",
                dateFormat.format(new Date()));
    }
}

Résultat de l'exécution :

2022-04-06 23:06:20.945 INFO 14604 --- [scheduling-1] com.fw.task.SpringTask : Task Cron Expression : L'heure actuelle est 23:06:20
2022-04-06 23:06:22.557 INFO 14604 --- [ scheduling-1] com.fw.task.SpringTask : Tâche avec délai initial : l'heure actuelle est 23:06:22
2022-04-06 23:06:22.557 INFO 14604 --- [ scheduling-1] com.fw.task.SpringTask : Tâche à taux fixe : L'heure actuelle est 23:06:22
2022-04-06 23:06 :25.955 INFO 14604 --- [ scheduling-1] com.fw.task.SpringTask : Tâche à retard fixe : L'heure actuelle est 23:06:25
2022-04-06 23:06:25.955 INFO 14604 --- [ planification -1] com.fw.task.SpringTask : Expression Cron de la tâche : l'heure actuelle est 23:06:25
2022-04-06 23:06:27.555 INFO 14604 --- [scheduling-1] com.fw.task. SpringTask : Tâche avec délai initial : L'heure actuelle est 23:06:27
2022-04-06 23:06:27.556 INFO 14604 --- [ scheduling-1] com.fw.task.SpringTask : Tâche à taux fixe : Heure actuelle est 23:06:27

@EnableScheduling doit activer les tâches planifiées, @Scheduled(cron = "0/5 * * * * ?") configure les règles pour les tâches planifiées. L'expression cron prend en charge de riches configurations de tâches planifiées. Ceux qui ne la connaissent pas peuvent la consulter

Avantages :

Simple et pratique à utiliser, prend en charge diverses configurations de tâches planifiées complexes

Inconvénients :

• Basé sur les tâches planifiées autonomes, il disparaîtra une fois la tâche planifiée redémarrée.

• Les tâches planifiées sont des tâches monothread par défaut. Si une exécution parallèle est requise, @EnableAsync doit être activé.

• Il n'existe pas de gestion graphique unifiée de la planification des tâches et il est impossible de contrôler les tâches planifiées

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!