springboot-async

在項目中，當訪問其餘人的接口較慢或者作耗時任務時，不想程序一直卡在耗時任務上，想程序可以並行執行， 咱們可使用多線程來並行的處理任務，也可使用spring提供的異步處理方式@Async。

Spring異步線程池的接口類，其實質是java.util.concurrent.Executor

Spring 已經實現的異常線程池：

1. SimpleAsyncTaskExecutor：不是真的線程池，這個類不重用線程，每次調用都會建立一個新的線程。
2. SyncTaskExecutor：這個類沒有實現異步調用，只是一個同步操做，只適用於不須要多線程的地方
3. ConcurrentTaskExecutor：Executor的適配類，不推薦使用。若是ThreadPoolTaskExecutor不知足要求時，才用考慮使用這個類
4. SimpleThreadPoolTaskExecutor：是Quartz的SimpleThreadPool的類。線程池同時被quartz和非quartz使用，才須要使用此類
5. ThreadPoolTaskExecutor：最常使用，推薦。其實質是對java.util.concurrent.ThreadPoolExecutor的包裝

在異步處理的方法上添加註解@Async，就會啓動一個新的線程去執行。

開啓異步配置

SpringBoot中開啓異步支持很是簡單，只須要在配置類上面加上註解@EnableAsync，同時定義本身的線程池便可。 也能夠不定義本身的線程池，則使用系統默認的線程池。這個註解能夠放在Application啓動類上，可是更推薦放在配置類上面。

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    // 省略...
}

 

異步處理方法分爲不返回結果和返回結果，這二者的處理是有區別的。

返回void

沒有結果返回的示例：

 1 @Component
 2 public class AsyncTask {
 3 
 4     private static final Logger LOGGER = LoggerFactory.getLogger(AsyncTask.class);
 5 
 6     @Async
 7     public void dealNoReturnTask() {
 8         LOGGER.info("返回值爲void的異步調用開始" + Thread.currentThread().getName());
 9         try {
10             Thread.sleep(3000);
11         } catch (InterruptedException e) {
12             e.printStackTrace();
13         }
14         LOGGER.info("返回值爲void的異步調用結束" + Thread.currentThread().getName());
15     }
16 }

 

返回Future

異步調用返回數據，Future表示在將來某個點獲取執行結果，返回數據類型能夠自定義

 1 @Async
 2 public Future<String> dealHaveReturnTask(int i) {
 3     LOGGER.info("asyncInvokeReturnFuture, parementer=" + i);
 4     Future<String> future;
 5     try {
 6         Thread.sleep(1000 * i);
 7         future = new AsyncResult<>("success:" + i);
 8     } catch (InterruptedException e) {
 9         future = new AsyncResult<>("error");
10     }
11     return future;
12 }

 

測試異常捕獲

1 @Async
2 public void testExpection() { 3 throw new AsyncException("error"); 4 }

 

異常處理

咱們能夠實現AsyncConfigurer接口，也能夠繼承AsyncConfigurerSupport類來實現。

在方法getAsyncExecutor()中建立線程池的時候，必須使用 executor.initialize()，否則在調用時會報線程池未初始化的異常。

 1 @Configuration
 2 @EnableAsync
 3 public class AsyncConfig implements AsyncConfigurer {
 4 
 5     @Override
 6     public Executor getAsyncExecutor() {
 7         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
 8         executor.setCorePoolSize(10);
 9         executor.setMaxPoolSize(100);
10         executor.setQueueCapacity(100);
11         executor.setWaitForTasksToCompleteOnShutdown(true);
12         executor.setAwaitTerminationSeconds(60 * 10);
13         executor.setThreadNamePrefix("AsyncThread-");
14         executor.initialize(); //若是不初始化，致使找到不到執行器
15         return executor;
16     }
17 
18     @Override
19     public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
20         return new AsyncExceptionHandler();
21     }
22 }

 

異步異常處理類：

 1 public class AsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
 2 
 3     private static final Logger LOOGER = LoggerFactory.getLogger(AsyncExceptionHandler.class);
 4 
 5     @Override
 6     public void handleUncaughtException(Throwable ex, Method method, Object... params) {
 7         LOOGER.error("Async method has uncaught exception, params:{}" + Arrays.toString(params));
 8 
 9         if (ex instanceof AsyncException) {
10             AsyncException asyncException = (AsyncException) ex;
11             LOOGER.error("asyncException:"  + asyncException.getMessage());
12         }
13 
14         LOOGER.error("Exception :", ex);
15     }
16 }

 

異步處理異常類：

 1 public class AsyncException extends RuntimeException {
 2 
 3     public AsyncException() {
 4         super();
 5     }
 6 
 7     public AsyncException(String msg) {
 8         super(msg);
 9     }
10 
11     public AsyncException(int code, String msg) {
12         super(msg);
13         this.code = code;
14     }
15 
16     private int code;
17 
18     public int getCode() {
19         return code;
20     }
21 
22     public void setCode(int code) {
23         this.code = code;
24     }
25 
26 }

 

在調用方法時，可能出現方法中拋出異常的狀況。Spring對於2種異步方法的異常處理機制以下：

1. 對於方法返回值是Futrue的異步方法: a) 在調用future的get時捕獲異常; b) 在異常方法中直接捕獲異常
2. 對於返回值是void的異步方法：經過AsyncUncaughtExceptionHandler處理異常

測試代碼

最後寫個測試代碼看看是否跟預期一致：

 1 @RunWith(SpringRunner.class)
 2 @SpringBootTest
 3 public class SpringbootAsyncApplicationTests {
 4 
 5     private static final Logger LOGGER = LoggerFactory.getLogger(SpringbootAsyncApplicationTests.class);
 6 
 7     @Autowired
 8     private AsyncTask asyncTask;
 9 
10     @Test
11     public void testAsync() throws InterruptedException, ExecutionException {
12 
13         asyncTask.dealNoReturnTask();
14 
15         Future<String> f = asyncTask.dealHaveReturnTask(1);
16 
17         LOGGER.info("主線程執行finished");
18 
19         LOGGER.info(f.get());
20         assertThat(f.get(), is("success:" + 1));
21 
22         asyncTask.testExpection();
23     }
24 }

 

執行日誌以下：

[           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService
[           main] c.c.s.SpringbootAsyncApplicationTests    : 主線程執行finished
[  AsyncThread-1] c.code.springbootasync.async.AsyncTask   : 返回值爲void的異步調用開始AsyncThread-1
[  AsyncThread-2] c.code.springbootasync.async.AsyncTask   : asyncInvokeReturnFuture, parementer=1
[           main] c.c.s.SpringbootAsyncApplicationTests    : success:1
[  AsyncThread-3] c.c.s.async.AsyncExceptionHandler        : Async method has uncaught exception, params:{}[]
[  AsyncThread-3] c.c.s.async.AsyncExceptionHandler        : asyncException:error

根據日誌的線程名稱很清楚的看出，每一個異步方法在線程池的不一樣線程中執行。

 

注：

實際運行中，還出現過一個問題，一個Service中的方法調用本身的另外一個方法，而後將這個方法加上@Async註解，然而並不起做用。 異步方法都應該放到單獨的異步任務Bean裏面去，而後將這個Bean注入到Service中便可。

 1 @Service
 2 public class DeviceService {
 3 
 4     @Resource
 5     private AsyncTask asyncTask;
 6     
 7     public int unbind(Integer id, ManagerInfo managerInfo) {
 8         // 前面省略...
 9         
10         // 開始異步推送消息
11         asyncTask.pushUnbindMsg(managerInfo, pos, location);
12     }
13 }