Gemeinschaft
Lernen
Tools-Bibliothek
KI-Tools
Freizeit
suchen
Deutsch
Heim > Java > javaLernprogramm > So implementieren Sie mehrere geplante Aufgaben in Spring Boot

So implementieren Sie mehrere geplante Aufgaben in Spring Boot

Java后端技术全栈
Freigeben： 2023-08-15 16:50:34
nach vorne
1507 Leute haben es durchsucht

In der tatsächlichen Entwicklung werden wir mehr oder weniger einige geplante Aufgabenszenarien verwenden. In diesem Artikel geht es um häufig verwendete geplante Aufgaben.

Zu den häufig verwendeten Lösungen zur Implementierung geplanter Aufgaben gehören die folgenden:

  • java.util.TimerTaskAufgabe. Mit dieser Methode kann Ihr Programm mit einer bestimmten Häufigkeit, jedoch nicht zu einem bestimmten Zeitpunkt ausgeführt werden. Im Allgemeinen weniger verwendet. Timer：这是java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。
  • ScheduledExecutorService：也jdk自带的一个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。
  • Spring Task：Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多。
  • Quartz
  • Die Aufgaben, die mit Spring 3.0 geliefert werden können wie folgt aussehen wie ein leichter Quarz und ist viel einfacher zu verwenden als Quarz.
    Erstellen Sie in der Datenbank eine Tabelle und speichern Sie Cron-Ausdrücke in der Tabelle.

    • nacos verwendet verteilte Konfiguration, um dynamische Konfigurations-Cron-Ausdrücke zu implementieren.

    XXL-JOB, verteilte feste Aufgabe

    🎜🎜Timer verwenden🎜🎜 🎜🎜🎜Dieser wird derzeit weniger im Projekt verwendet und der Democode wird direkt gepostet. 🎜🎜Eine ausführliche Einführung finden Sie in der API: 🎜
    public class TestTimer {
    public static void main(String[] args) {
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                System.out.println("task  run:"+ new Date());
            }
        };
        Timer timer = new Timer();
        //安排指定的任务在指定的时间开始进行重复的固定延迟执行。这里是每3秒执行一次
        timer.schedule(timerTask,10,3000);
    }
}
    Nach dem Login kopieren

    Verwenden Sie ScheduledExecutorService

    Diese Methode ähnelt Timer, schauen Sie sich einfach die Demo an: 

    public class TestScheduledExecutorService {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
        // 参数：1、任务体 2、首次执行的延时时间
        //      3、任务执行间隔 4、间隔时间单位
        service.scheduleAtFixedRate(()->System.out.println("task ScheduledExecutorService "+new Date()), 0, 3, TimeUnit.SECONDS);
    }
}
    Nach dem Login kopieren

    Verwenden Sie Spring Task

    Einfache geplante Aufgabe

    Im Spring Boot-Projekt können wir Benutze es Sehr elegante Annotation zum Implementieren geplanter Aufgaben. Erstellen Sie zunächst ein Projekt und importieren Sie Abhängigkeiten: 

    <dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>
  <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
</dependencies>
    Nach dem Login kopieren

    Erstellen Sie eine Aufgabenklasse: 

    @Slf4j
@Component
public class ScheduledService {
    @Scheduled(cron = "0/5 * * * * *")
    public void scheduled(){
        log.info("=====>>>>>使用cron  {}",System.currentTimeMillis());
    }
    @Scheduled(fixedRate = 5000)
    public void scheduled1() {
        log.info("=====>>>>>使用fixedRate{}", System.currentTimeMillis());
    }
    @Scheduled(fixedDelay = 5000)
    public void scheduled2() {
        log.info("=====>>>>>fixedDelay{}",System.currentTimeMillis());
    }
}
    Nach dem Login kopieren

    Verwenden Sie die Annotation @EnableScheduling für die Hauptklasse, um die Unterstützung für geplante Aufgaben zu aktivieren, und starten Sie dann das Projekt

    So implementieren Sie mehrere geplante Aufgaben in Spring Boot

    Sie können sehen, dass alle geplanten Aufgaben nacheinander im selben Thread ausgeführt wurden. Wenn die Anzahl der geplanten Aufgaben zunimmt, ist dies definitiv kein Problem Wenn der Fehler stecken bleibt, können andere Aufgaben nicht ausgeführt werden.

    Multithread-Ausführung

    In herkömmlichen Spring-Projekten können wir die Aufgabenkonfiguration in der XML-Konfigurationsdatei hinzufügen. In Spring Boot-Projekten verwenden wir im Allgemeinen die Konfigurationsklasse config, um die Konfiguration hinzuzufügen. Erstellen Sie daher eine neue AsyncConfig Klasse AsyncConfig类

    @Configuration
@EnableAsync
public class AsyncConfig {
     /*
    此处成员变量应该使用@Value从配置中读取
     */
    private int corePoolSize = 10;
    private int maxPoolSize = 200;
    private int queueCapacity = 10;
    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.initialize();
        return executor;
    }
}
    Nach dem Login kopieren

    @Configuration：表明该类是一个配置类@EnableAsync：开启异步事件的支持

    然后在定时任务的类或者方法上添加@Async

    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
    Nach dem Login kopieren
    Nach dem Login kopieren

    @Configuration: Gibt an, dass die Klasse eine Konfigurationsklasse ist@EnableAsync: Unterstützung für asynchrone Ereignisse aktivieren

    So implementieren Sie mehrere geplante Aufgaben in Spring BootDann in der Klasse oder Methode der geplanten Aufgabe hinzufügen @Async . Starten Sie abschließend das Projekt neu. Jede Aufgabe befindet sich in einem anderen Thread.

    Konfiguration der Ausführungszeit🎜🎜In der oben genannten geplanten Aufgabe verwenden wir die Annotation @Scheduled für die Methode, um die Ausführungszeit der Aufgabe festzulegen, und verwenden drei Attributkonfigurationsmethoden: 🎜
    1. fixedRate: Definieren Sie eine geplante Aufgabe, die in einer bestimmten Häufigkeit ausgeführt wird.
    2. fixedDelay: Definieren Sie eine geplante Aufgabe, die in einer bestimmten Häufigkeit ausgeführt wird. Der Unterschied zu den oben genannten besteht darin, dass das Ändern des Attributs mit initialDelay zusammenwirken kann Definieren Sie die verzögerte Ausführungszeit der Aufgabe.
    3. cron: Aufgabenausführungszeit über Ausdrücke konfigurieren

    Detaillierte Erklärung von Cron-Ausdrücken

    Ein Cron-Ausdruck besteht aus mindestens 6 (vielleicht 7) Zeitelementen, die durch Leerzeichen getrennt sind. In der Reihenfolge:

    • Sekunden (0~59)
    • Minuten (0~59)
    • 3 Stunden (0~23)
    • 4 Tage (0~31)
    • 5 Monate (0~11)
    • 6 Wochen (1~7 1=SONNE oder SO, MO, DIE, MITTWOCH, DO, FREI, SA)
    • Jahr (1970-2099)

    Jedes Element kann ein Wert (z. B. 6), ein kontinuierliches Intervall (9-12), ein Intervall (8-18/4) (/ bedeutet alle 4 Stunden), eine Liste (1, 3, 5) oder ein Platzhalter sein. Da sich die beiden Elemente „Tag des Monats“ und „Tag der Woche“ gegenseitig ausschließen, muss eines davon festgelegt werden. Konfigurationsbeispiel: