Ausführliche Erläuterung der Verwendung von @Async im Frühjahr und einfache Beispieleinführung

Dieser Artikel stellt hauptsächlich die detaillierte Erklärung und einfache Beispiele der @Async-Nutzung im Frühling vor. Freunde, die es benötigen, können sich auf

@Async-Nutzung im Frühling

beziehen Einführung: In Java-Anwendungen wird die Interaktionsverarbeitung in den meisten Fällen durch Synchronisierung erreicht. Bei der Interaktion mit Systemen von Drittanbietern kann es jedoch leicht zu langsamen Reaktionen kommen. In der Vergangenheit wurden hierfür meist mehrere Threads verwendet Tatsächlich wurde nach Spring 3.x @Async integriert, um dieses Problem perfekt zu lösen. In diesem Artikel wird die Verwendung von @Async vollständig vorgestellt.

1. Was ist ein asynchroner Aufruf?

Bevor wir asynchrone Aufrufe erklären, werfen wir zunächst einen Blick auf die Definition synchroner Aufrufe. Synchronisierung bedeutet, dass der gesamte Verarbeitungsprozess nacheinander ausgeführt wird und nach Abschluss jedes Prozesses die Ergebnisse zurückgegeben werden. Beim asynchronen Aufruf werden nur die aufrufenden Anweisungen gesendet, und der Aufrufer muss nicht darauf warten, dass die aufgerufene Methode vollständig ausgeführt wird, sondern führt stattdessen den folgenden Prozess weiter aus.

Beispielsweise müssen in einem bestimmten Aufruf die drei Prozessmethoden A, B und C nacheinander aufgerufen werden. Wenn es sich um synchrone Aufrufe handelt, müssen sie nacheinander ausgeführt werden, bevor die Prozessausführung abgeschlossen ist. Wenn B eine asynchrone Aufrufmethode ist, wartet der Aufruf von B nach der Ausführung von A nicht auf den Abschluss von B, sondern beginnt mit der Ausführung und ruft C auf. Nachdem C ausgeführt wurde, bedeutet dies, dass der Prozess abgeschlossen ist.

2. Herkömmliche asynchrone Aufrufverarbeitungsmethoden

In Java basieren sie bei der Bearbeitung ähnlicher Szenarien normalerweise auf der Erstellung unabhängiger Threads, um die entsprechenden asynchronen Aufruflogikdurchläufe abzuschließen Der Ausführungsprozess zwischen dem Hauptthread und verschiedenen Threads, sodass der Hauptthread nach dem Starten eines unabhängigen Threads ohne Anhalten und Warten weiter ausgeführt wird.

3. Einführung in @Async

In Spring werden Methoden, die auf der @Async-Annotation basieren, als asynchrone Methoden bezeichnet Der Aufrufer muss nicht auf den Abschluss eines Threads warten, bevor er mit anderen Vorgängen fortfahren kann.

So aktivieren Sie @Async in Spring

Aktivierung basierend auf der Java-Konfiguration:

@Configuration 
@EnableAsync 
public class SpringAsyncConfig { ... }

Basierend auf der XML-Konfiguration Die Dateiaktivierungsmethode ist wie folgt konfiguriert:

<task:executor id="myexecutor" pool-size="5" /> 
<task:annotation-driven executor="myexecutor"/>

Die oben genannten sind die beiden Definitionsmethoden.

4. Aufruf von

basierend auf @Async ohne Rückgabewert. Das Beispiel lautet wie folgt:

@Async //标注使用 
public void asyncMethodWithVoidReturnType() { 
  System.out.println("Execute method asynchronously. " 
   + Thread.currentThread().getName()); 
}

verwendet Die Methode ist sehr einfach, ein Etikett kann alle Probleme lösen.

5. Aufruf basierend auf dem @Async-Rückgabewert

Beispiele sind wie folgt:

@Async 
public Future<String> asyncMethodWithReturnType() { 
  System.out.println("Execute method asynchronously - " 
   + Thread.currentThread().getName()); 
  try { 
    Thread.sleep(5000); 
    return new AsyncResult<String>("hello world !!!!"); 
  } catch (InterruptedException e) { 
    // 
  } 
  
  return null; 
}

Aus dem obigen Beispiel können Sie ersehen, dass der zurückgegebene Datentyp der Typ Future ist, bei dem es sich um eine Schnittstelle handelt. Der spezifische Ergebnistyp ist AsyncResult, worauf Sie achten sollten.

Beispiel für den Aufruf einer asynchronen Methode, die ein Ergebnis zurückgibt:

public void testAsyncAnnotationForMethodsWithReturnType() 
  throws InterruptedException, ExecutionException { 
  System.out.println("Invoking an asynchronous method. " 
   + Thread.currentThread().getName()); 
  Future<String> future = asyncAnnotationExample.asyncMethodWithReturnType(); 
  
  while (true) { ///这里使用了循环判断，等待获取结果信息 
    if (future.isDone()) { //判断是否执行完毕 
      System.out.println("Result from asynchronous process - " + future.get()); 
      break; 
    } 
    System.out.println("Continue doing something else. "); 
    Thread.sleep(1000); 
  } 
}

Analyse: Diese erhalten die Ergebnisinformationen der asynchrone Methode durch Dies wird erreicht, indem der Status von Future ständig überprüft wird, um festzustellen, ob die aktuelle asynchrone Methode ausgeführt wurde.

6. Ausnahmebehandlungsmechanismus basierend auf @Async-Aufrufen

Wenn bei einer asynchronen Methode eine Ausnahme auftritt, ist es für den Aufrufer unmöglich, sie wahrzunehmen. Wenn tatsächlich eine Ausnahmebehandlung erforderlich ist, gehen Sie wie folgt vor:

1. Passen Sie den Task-Executor an, der AsyncTaskExecutor implementiert.

Definieren Sie hier die Logik und Methode zur Behandlung bestimmter Ausnahmen.

2. Konfigurieren Sie einen benutzerdefinierten TaskExecutor, um den integrierten Task-Executor zu ersetzen.

Beispielschritt 1, benutzerdefinierter TaskExecutor

public class ExceptionHandlingAsyncTaskExecutor implements AsyncTaskExecutor { 
  private AsyncTaskExecutor executor; 
  public ExceptionHandlingAsyncTaskExecutor(AsyncTaskExecutor executor) { 
    this.executor = executor; 
   } 
   ////用独立的线程来包装，@Async其本质就是如此 
  public void execute(Runnable task) {    
   executor.execute(createWrappedRunnable(task)); 
  } 
  public void execute(Runnable task, long startTimeout) { 
    /用独立的线程来包装，@Async其本质就是如此 
    executor.execute(createWrappedRunnable(task), startTimeout);      
  }  
  public Future submit(Runnable task) { return executor.submit(createWrappedRunnable(task)); 
    //用独立的线程来包装，@Async其本质就是如此。 
  }  
  public Future submit(final Callable task) { 
   //用独立的线程来包装，@Async其本质就是如此。 
    return executor.submit(createCallable(task));  
  }  
   
  private Callable createCallable(final Callable task) {  
    return new Callable() {  
      public T call() throws Exception {  
         try {  
           return task.call();  
         } catch (Exception ex) {  
           handle(ex);  
           throw ex;  
          }  
         }  
    };  
  } 
 
  private Runnable createWrappedRunnable(final Runnable task) {  
     return new Runnable() {  
       public void run() {  
         try { 
           task.run();  
         } catch (Exception ex) {  
           handle(ex);  
          }  
      } 
    };  
  }  
  private void handle(Exception ex) { 
   //具体的异常逻辑处理的地方 
   System.err.println("Error during @Async execution: " + ex); 
  } 
}

Analyse: Es kann festgestellt werden, dass es AsyncTaskExecutor implementiert und unabhängige Threads verwendet, um bestimmte Methodenoperationen auszuführen. In createCallable und createWrapperRunnable werden die Methode und der Mechanismus zur Ausnahmebehandlung definiert.

handle() ist der Punkt, an dem wir uns in Zukunft auf die Ausnahmebehandlung konzentrieren müssen.

Inhalt in der Konfigurationsdatei:

<task:annotation-driven executor="exceptionHandlingTaskExecutor" scheduler="defaultTaskScheduler" /> 
<bean id="exceptionHandlingTaskExecutor" class="nl.jborsje.blog.examples.ExceptionHandlingAsyncTaskExecutor"> 
  <constructor-arg ref="defaultTaskExecutor" /> 
</bean> 
<task:executor id="defaultTaskExecutor" pool-size="5" /> 
<task:scheduler id="defaultTaskScheduler" pool-size="1" />

Analyse: Die Konfiguration hier verwendet einen benutzerdefinierten TaskExecutor, um den Standard-TaskExecutor zu ersetzen.

7. Transaktionsverarbeitungsmechanismus in @Async-Aufrufen

Mit @Async gekennzeichnete Methoden werden in ihnen auch mit @Transactional gekennzeichnet; , ist die Transaktionsverwaltungssteuerung nicht verfügbar, da es sich um einen Vorgang handelt, der auf asynchroner Verarbeitung basiert.

Wie kann man diesen Vorgängen also das Transaktionsmanagement hinzufügen? Methoden, die Transaktionsverwaltungsvorgänge erfordern, können in die asynchrone Methode eingefügt werden, und @Transactional.

wird zur intern aufgerufenen Methode hinzugefügt. Beispiel: Methode A ist mit @Async/@Transactional gekennzeichnet, eine Transaktion jedoch nicht zu Kontrollzwecken generiert werden.

Methode B wird mit @Async annotiert. C und D werden in B aufgerufen. C/D werden jeweils mit @Transactional annotiert, was den Zweck der Transaktionssteuerung erreichen kann.

8. Zusammenfassung

Durch die obige Beschreibung sollten wir die Methoden und Vorsichtsmaßnahmen für die Verwendung von @Async kennen.

Das Obige ist eine ausführliche Erklärung und einfache Beispiele für die Verwendung von @Async im Frühjahr. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).