Von @Async in Java asynchron aufgerufene Methoden

Vorwort

Asynchroner Aufruf und synchroner Aufruf

• Synchroner Aufruf: Nacheinander ausführen, das Ergebnis durch den Aufruf zurückgeben und den nächsten Aufruf erneut ausführen

• Asynchroner Aufruf: Führen Sie den nächsten Aufruf aus, ohne auf das zu warten zurückzugebendes Ergebnis Aufruf

1. @Async-Erklärung

Der Annotationscode von @Async lautet wie folgt:

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Async {
    String value() default "";
}

Annotationen können in Typen und Methoden verwendet werden
Der Wert wird durch Wert definiert und der Standardwert ist leer

Im Allgemeinen muss diese Annotation mit @EnableAsync abgeglichen werden. Der Ursprungscode lautet wie folgt:

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AsyncConfigurationSelector.class})
public @interface EnableAsync {
    Class<? extends Annotation> annotation() default Annotation.class;

    boolean proxyTargetClass() default false;

    AdviceMode mode() default AdviceMode.PROXY;

    int order() default Integer.MAX_VALUE;
}

Wird hauptsächlich durch diese Annotation für den Konfigurationsstart in der Startup-Klasse platziert.

Fügen Sie Folgendes in der Startup-Klasse hinzu:

@SpringbootApplication
@EnableAsync
public class Application{
    public static void main(String[] args){
        SrpingApplication.run(Application.class, args);
    }
}

2. Verwendung

2.1 Synchroner Aufruf

Das Funktionsergebnis kann nur vom Aufruf bis zur Rückkehr ausgeführt werden. Ein Schritt, synchroner Aufruf genannt

Code der Serviceschicht:

public class Service{
    public void test01() throws InterruptedException{
        Thread.sleep(5000);
        System.out.println("保存日志");
    }
}

Codemodul der Steuerschicht:

public class Controler{
    @Autowired
    private Service service;

    @GetMapping("/test")
    public String getTest(){
        try{
            System.out.println("开始");
            service.test01();
            System.out.println("结束");            
        }catch(InterruptedException e){
            e.prinStackTrace();
        }
    }
    
}

Nach dem Start durch die Startup-Klasse von springboot

Die Ausgabe lautet wie folgt:

Start

// Dies bedeutet, 5 Sekunden zu warten. Das Terminal wird weder angezeigt noch geschlossen

Ende

2.2 Asynchroner Aufruf

Asynchroner Aufruf, die ausgeführte Funktion kann den nächsten Schritt ausführen, ohne auf das Rückgabeergebnis warten zu müssen und Hinzufügen von Anmerkungen zur Startup-Klasse

public class Service{
    @Async
    public void test01() throws InterruptedException{
        Thread.sleep(500);
        System.out.println("保存日志");
    }
}

3. Passen Sie den Thread-Pool an

Einige grundlegende Kenntnisse über den Thread-Pool finden Sie in meinem vorherigen Artikel:

So schließen Sie Threads und Thread-Pools in Java korrekt (Code-Praxis umfasst Quellcode). Code-Analyse)

Detaillierte Analyse zum Erstellen eines Java-Thread-Pools (vollständig)

Wenn Sie keinen Thread-Pool angeben, wird als Standard-Thread-Pool SimpleAsyncTaskExecutor verwendet (wenn eine Aufgabe kommt, erstellen Sie einfach einen Thread. Threads werden kontinuierlich erstellt Dies führt dazu, dass die CPU zu hoch ist und OOM verursacht. Es wird allgemein empfohlen, ThreadPoolExecutor zu verwenden (Ressourcen des Thread-Pools löschen und Risiken vermeiden). Die Details lauten wie folgt:

newFixedThreadPool: Auch wenn die Anzahl der Threads festgelegt ist, ist die Aufgabenwarteschlange immer noch unbegrenzt (die maximale Anzahl von Threads wird nur erstellt, wenn die Warteschlange voll ist), sodass OOM auftritt

newCachedThreadPool: Ja Es gibt keine Obergrenze für die maximale Anzahl von Threads und es wird eine große Anzahl von Threads erstellt. Einfach einzufrieren oder direkt OOM. Die Thread-Pool-Konfiguration kann für eine bessere Ressourcennutzung über einen benutzerdefinierten Thread-Pool angepasst werden. @Async Diese Anmerkung sieht aus für die AsyncConfigurer-Schnittstelle (die Implementierungsklasse ist AsyncConfigurerSupport, die Standardkonfiguration und -methoden sind leer), sodass die Schnittstelle überschrieben werden kann, um den Thread-Pool anzugeben.

Durch Implementierung der Schnittstelle AsyncConfigurer

• Inherit AsyncConfigurerSupport

• Custom TaskExecutor (ersetzt den integrierten Task Executor)

Die dritte Methode:

Definieren Sie einige Thread-Pools in der Anwendung .xml-Variable

public class Controler{
    @Autowired
    private Service service;

    @GetMapping("/test")
    public String getTest(){
        try{
            System.out.println("开始");
            service.test01();
            System.out.println("结束");            
        }catch(InterruptedException e){
            e.prinStackTrace();
        }
    }
    
}

• Der benutzerdefinierte Thread-Pool sieht wie folgt aus

  @SpringbootApplication
  @EnableAsync
  public class Application{
      public static void main(String[] args){
          SrpingApplication.run(Application.class, args);
      }
  }

  Das obige ist der detaillierte Inhalt vonVon @Async in Java asynchron aufgerufene Methoden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!