序言：Spring中@Async

根據Spring的文件說明，預設採用的是單執行緒的模式的。所以在Java應用中，絕大多數情況下都是通過同步的方式來實現互動處理的。

那麼當多個任務的執行勢必會相互影響。例如，如果A任務執行時間比較長，那麼B任務必須等到A任務執行完畢後才會啟動執行。又如在處理與第三方系統互動的時候，容易造成響應遲緩的情況，之前大部分都是使用多執行緒來完成此類任務，其實，在spring3.x之後，已經內建了@Async來完美解決這個問題。

1. 何為非同步呼叫？

在解釋之前，我們先來看二者的定義：

同步呼叫：順序執行，需等待上一個任務執行完畢

就是整個處理過程順序執行，當各個過程都執行完畢，並返回結果。

非同步呼叫：接收到指令就執行，無需等待

則是隻是傳送了呼叫的指令，呼叫者無需等待被呼叫的方法完全執行完畢；而是繼續執行下面的流程。

例如， 在某個呼叫中，需要順序呼叫A,B,C三個過程方法：
如他們都是同步呼叫，則需要將他們都順序執行完畢之後，方算作過程執行完畢；如B為一個非同步的呼叫方法，則在執行完A之後，呼叫B，並不等待B完成，而是執行開始呼叫C，待C執行完畢之後，就意味著這個過程執行完畢了。

如圖所示：

2. 常規的非同步呼叫處理方式

在Java中，一般在處理類似的場景之時，都是基於建立獨立的執行緒去完成相應的非同步呼叫邏輯，通過主執行緒和不同的執行緒之間的執行流程，從而在啟動獨立的執行緒之後，主執行緒繼續執行而不會產生停滯等待的情況。或是使用TaskExecutor執行非同步執行緒，參看http://www.cnblogs.com/wihainan/p/6098970.html

3. 如何在Spring中啟用@Async？

3.0、@Async介紹

在Spring中，基於@Async標註的方法，稱之為非同步方法；這些方法在執行的時候，將會在獨立的執行緒中被執行，呼叫者無需等待它的完成，即可繼續其他的操作。

3.1、啟用@Async註解

3.1.1、基於Java配置的啟用方式

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

3.1.2、基於SpringBoot配置的啟用方式

@SpringBootApplication
@EnableAsync
public class SpringBootApplication {
  public static void main(String[] args) {
    SpringApplication.run(SpringBootApplication.class,args);
  }
}

3.2、使用@Async註解，宣告方法為非同步呼叫

3.2.0、在無返回值方法上使用：

在方法上申明為非同步呼叫方法即可

  @Async //標註使用
  public void downloadFile() throws Exception { ... } 

3.2.1、在有返回值方法上使用

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

以上示例可以發現，返回的資料型別為Future型別，其為一個介面。具體的結果型別為AsyncResult,這個是需要注意的地方。

呼叫返回結果的非同步方法示例:

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

這些獲取非同步方法的結果資訊，是通過不停的檢查Future的狀態來獲取當前的非同步方法是否執行完畢來實現的。

4. 基於@Async呼叫中的異常處理機制

在非同步方法中，如果出現異常，對於呼叫者caller而言，是無法感知的。如果確實需要進行異常處理，則按照如下方法來進行處理：

自定義實現AsyncTaskExecutor的任務執行器
在這裡定義處理具體異常的邏輯和方式。

配置由自定義的TaskExecutor替代內建的任務執行器

示例步驟1，自定義的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); 
  } 
}

分析： 可以發現其是實現了AsyncTaskExecutor,用獨立的執行緒來執行具體的每個方法操作。在createCallable和createWrapperRunnable中，定義了異常的處理方式和機制。

handle()就是未來我們需要關注的異常處理的地方。
xml配置檔案中的內容：

<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" />

也可以使用註解的形式將其配置註冊到bean中。

5. @Async呼叫中的事務處理機制

在@Async標註的方法，同時也使用@Transactional進行標註；在其呼叫資料庫操作之時，將無法產生事務管理的控制，原因就在於其是基於非同步處理的操作。

那該如何給這些操作新增事務管理呢？

可以將需要事務管理操作的方法放置到非同步方法內部，在內部被呼叫的方法上新增@Transactional

示例：

方法A， 使用了@Async/@Transactional來標註，但是無法產生事務控制的目的。

方法B， 使用了@Async來標註，B中呼叫了C、D，C/D分別使用@Transactional做了標註，則可實現事務控制的目的。

6. 參考文章：

[1]、https://www.cnblogs.com/wihainan/p/6516858.html
[2]、http://www.cnblogs.com/wihainan/p/6098970.html

到此這篇關於深入理解Spring註解@Async解決非同步呼叫問題的文章就介紹到這了,更多相關Spring註解@Async解決非同步呼叫內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！