@Async注解的使用

　　在 Java應用中，絕大多數情況下都是通過同步的方式來實現交互處理的；但是在處理與第三方系統交互的時候，容易造成響應遲緩的情況，之前大部分都是使用多線程來完成此類任務，其實，在 spring 3.x之后，就已經內置了@Async來完美解決這個問題，本文將完成介紹@Async的用法。

 

1.  何為異步調用？

    在解釋異步調用之前，我們先來看同步調用的定義；同步就是整個處理過程順序執行，當各個過程都執行完畢，並返回結果。 異步調用則是只是發送了調用的指令，調用者無需等待被調用的方法完全執行完畢；而是繼續執行下面的流程。

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

　　2.  常規的異步調用處理方式

    在Java中，一般在處理類似的場景之時，都是基於創建獨立的線程去完成相應的異步調用邏輯，通過主線程和不同的線程之間的執行流程，從而在啟動獨立的線程之后，主線程繼續執行而不會產生停滯等待的情況。

　　3. @Async介紹

   在Spring中，基於@Async標注的方法，稱之為異步方法；這些方法將在執行的時候，將會在獨立的線程中被執行，調用者無需等待它的完成，即可繼續其他的操作。

　　如何在Spring中啟用@Async

      基於Java配置的啟用方式：

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

基於XML配置文件的啟用方式，配置如下：

spring對多線程做了很好的支持.主要有@Async @EnableAsync注解.

 

@Async.直接加在方法上,調用該方法時會自動創建一個線程.線程池默認使用SimpleAsyncTaskExecutor.不重用線程,每次調用都會創建一個新的線程.所以單單使用@Async可能會產生並發問題.需要自定義線程池.使用@Async有以下幾個注意事項:

 

1.要異步執行的方法加上@Async

 

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

2.調用異步方法需要配置上注解@EnableAsync.可以在spring入口類加注解,也可以在需要調用異步方法的類上注解也可以直接在配置類加.

 

3.異步方法不能和調用方法放在一個類里面,必須不同類間調用,所以,很顯然異步方法都是public.

 

4. 在@Async標注的方法，同時也適用了@Transactional進行了標注的情況；在其調用數據庫操作之時，將無法產生事務管理的控制，原因就在於其是基於異步處理的操作。 那該如何給這些操作添加事務管理呢？可以將需要事務管理操作的方法放置到異步方法內部，在內部被調用的方法上添加@Transactional.

 

5.不自定義異步方法的線程池默認使用SimpleAsyncTaskExecutor.SimpleAsyncTaskExecutor：不是真的線程池，這個類不重用線程，每次調用都會創建一個新的線程。並發大的時候會產生嚴重的性能問題.

 

6.@Async注解一般用在類的方法上，如果用在類上，那么這個類所有的方法都是異步執行的；

 

7.返回值:需要返回值用AsyncResult或者CompletableFuture

 

8.@Async默認使用Bean Name為executor的線程池。也可以根據Bean Name指定特定線程池.

 

9.線程池:線程池是一種多線程處理形式，處理過程中將任務添加到隊列，然后在創建線程后自動啟動這些任務。線程池線程都是后台線程。spring中可以寫一個線程池的配置類交給spring管理.為了提高項目的魯棒性,不同業務配置不同線程池.

@Bean
    public Executor asyncServiceExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //ThreadPoolTaskExecutor executor = new VisiableThreadPoolTaskExecutor();
 
        //配置核心線程數,線程池維護線程的最少數量
        executor.setCorePoolSize(5);
 
        //配置最大線程數,線程池維護線程的最大數量
        executor.setMaxPoolSize(5);
 
        //配置隊列大小,緩存隊列
        executor.setQueueCapacity(99999);
 
        //配置線程池中的線程的名稱前綴
        executor.setThreadNamePrefix("async-service-");
 
        // rejection-policy：當pool已經達到max size的時候，如何處理新任務
 
        // CALLER_RUNS：不在新線程中執行任務，而是有調用者所在的線程來執行
 
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
 
        //允許的空閑時間 當線程空閑時間達到keepAliveTime時，線程會退出，直到線程數量=corePoolSize
        //executor.setKeepAliveSeconds(1);
 
        //執行初始化
        executor.initialize();
 
        return executor;
 
    }

@Async配置有返回的的方式：

    @Async
    public Future<String> doTaskAfterTwoSecondWithReturn() throws InterruptedException {
        long currentTimeMillis = System.currentTimeMillis();
        Thread.sleep(2000);
        System.out.println("線程名稱："+Thread.currentThread().getName());
        long currentTimeMillis1 = System.currentTimeMillis();
        System.out.println("task2任務耗時:"+(currentTimeMillis1-currentTimeMillis)+"ms");
        return new AsyncResult<String>("task2執行完畢");
    }

@Async配置沒有返回值

    @Async
    public void doTaskAfterThreeSecond() throws InterruptedException {
        long currentTimeMillis = System.currentTimeMillis();
        Thread.sleep(3000);
        long currentTimeMillis1 = System.currentTimeMillis();
        System.out.println("task1任務耗時:"+(currentTimeMillis1-currentTimeMillis)+"ms");

    }

 

6. 基於@Async調用中的異常處理機制

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

    1.  自定義實現AsyncTaskExecutor的任務執行器

         在這里定義處理具體異常的邏輯和方式。

    2.  配置由自定義的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()就是未來我們需要關注的異常處理的地方。

      配置文件中的內容：

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

分析： 這里的配置使用自定義的taskExecutor來替代缺省的TaskExecutor。

　　### @Async調用中的事務處理機制

    在@Async標注的方法，同時也適用了@Transactional進行了標注；在其調用數據庫操作之時，將無法產生事務管理的控制，原因就在於其是基於異步處理的操作。

     那該如何給這些操作添加事務管理呢？可以將需要事務管理操作的方法放置到異步方法內部，在內部被調用的方法上添加@Transactional.

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

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