@ASYNC，@ENABLEASYNC，ASYNCCONFIGURER 自定义线程

1. @ASYNC

在spring中，可以通过@EnableAsync + @Async两个注解非常快捷的实现异步。步骤如下：

启动类加上: @EnableAsync注解 并且在service上加上@Async注解

1. @SpringBootApplication(

2. exclude = {CodecsAutoConfiguration.class},

3. scanBasePackages = {

4. "com.arvato.config",

5. "com.arvato.service",

6. "com.arvato.controller"

7. })

8. @EnableAsync

9. @MapperScan(basePackages = "com.arvato.mapper.config")

10. public class WebFluxApplication {

11. public static void main(String[] args) {

12. SpringApplication.run(WebFluxApplication.class, args);

13. }

14. }

17. @RestController

18. @RequestMapping("/wxwork/sync")

19. public class WxworkSyncController {

21. @Autowired

22. private WxworkSyncService wxworkSyncService;

24. @GetMapping

25. public Mono<String> sync() {

26. // 异步处理业务

27. wxworkSyncService.sync();

28. return Mono.just("直接返回处理成功");

29. }

31. }

33. @Service

34. public class WxworkSyncService {

35. @Async

36. public void sync() {

37. try {

38. Thread.sleep(1000);

39. } catch (InterruptedException e) {

40. e.printStackTrace();

41. }

42. System.out.println(System.currentTimeMillis() + "--" + Thread.currentThread().getName());

43. }

44. }

然后疯狂发请求测试异步情况，并且打印线程名。我们发现默认情况下,每一次调用都是开启一个新的线程，截图如下：

可以看出来，@Async用的是SimpleAsyncTaskExecutor线程池，但是如果没有对SimpleAsyncTaskExecutor做策略配置的话，是不复用线程的，这是对服务器资源的浪费。 

2.自定义线程池

自定义线程池很简单，只要实现AsyncConfigurer接口，并且重写getAsyncExecutor方法。

1. import lombok.extern.slf4j.Slf4j;

2. import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;

3. import org.springframework.context.annotation.Configuration;

4. import org.springframework.scheduling.annotation.AsyncConfigurer;

5. import org.springframework.scheduling.annotation.EnableAsync;

6. import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

7. import java.util.Arrays;

8. import java.util.concurrent.Executor;

9. import java.util.concurrent.RejectedExecutionException;

11. @Configuration

12. @EnableAsync(proxyTargetClass = true)

13. @Slf4j

14. public class AsyncConfig implements AsyncConfigurer {

16. @Override

17. public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {

18. return (ex, method, params) ->

19. log.error("Unexpected error occurred invoking async method: " + method +

20. ", args: " + Arrays.toString(params), ex);

21. }

23. /**

24. * 自定义异步线程池

25. * @return executor

26. */

27. @Override

28. public Executor getAsyncExecutor() {

29. ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

30. executor.setCorePoolSize(10);

31. executor.setMaxPoolSize(20);

32. executor.setQueueCapacity(1000);

33. executor.setThreadNamePrefix("MyExecutor-");

34. executor.setWaitForTasksToCompleteOnShutdown(false);

35. // 设置拒绝策略

36. executor.setRejectedExecutionHandler((r, e) -> {

37. throw new RejectedExecutionException("Task " + r.toString() +

38. " rejected from " +

39. e.toString());

40. });

41. executor.initialize();

42. return executor;

43. }

44. }

再次发请求测试: