A.10 springboot async

1. 背景

服务端为了达到快速响应接口调用方的，通常使用的办法是将业务中部分非事物及非关键步骤改为异步执行，从而提高接口的响应速度。使用异步的方法有消息队列，内存队列，开启线程等，本文主要讲解在springboot环境中如何使用线程进行异步。

在非Spring项目或者普通的java项目中，想要实现异步大多是使用多线程，可以自己实现Runnable接口或者继承Thread类，或者使用Executors线程池。

2. spring环境下的异步

Spring（SpringBoot）中则提供了方便的方法执行异步调用。
异步常见的两种情况：

• 无返回值的异步
• 有返回值的异步

2.1 开启异步调用

增加 @EnableAsync 注解

@SpringBootApplication
@EnableAsync
public class DemoApp {

    private static ConfigurableApplicationContext ctx;
    
    public static void main(String[] args) {
        ctx = SpringApplication.run(DemoApp.class, args);
    }
}

2.2 无返回值的异步

1、异步方法

在方法体上增加有 @Async 的方法即为异步方法

@Service
public class TaskService {
    
    @Async
    public void task1(String name) {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Hello, " + name);
    }
    
    @Async
    public void task2(String name) {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Bye, " + name);
    }
}

2、调用方法

通过测试能够发现，task1方法和task2方法在没有执行完成的情况下，主线程已经将结果返回。明显起到了异步的效果。有效的减少了主线程的响应时间。

@RestController
@Api(tags="异步测试")
@RequestMapping(path="task")
public class TaskController {
    
    @Autowired
    private TaskService taskService;
    
    @RequestMapping(path="one", method=RequestMethod.GET)
    public ResponseEntity<String> one() {
        //子线程异步执行
        taskService.task1("Tom");
        taskService.task2("Tom");
        //主线程返回提前返回数据
        return ResponseEntity.ok().body("success");
    }
}

2.3 有返回值的异步

1、异步方法

在方法体上增加有 @Async 的方法即为异步方法

@Service
public class TaskFutureService {
    
    @Async
    public Future<String> task1(String name) {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new AsyncResult<String>("Hello, " + name);
    }
    
    @Async
    public Future<String> task2(String name) {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new AsyncResult<String>("Bye, " + name);
    }
}

2、异步调用

通过测试能够发现，task1方法和task2方法会并发执行，主线程会一直等待 task1 和 task2 的方法执行完成过后拿到具体的返回值，有效的减少的程序的总运行时间。

@RestController
@Api(tags="异步测试")
@RequestMapping(path="task")
public class TaskController {
    
//  @Autowired
//  private TaskService taskService;
    
    @Autowired
    private TaskFutureService taskFutureService;
 
//  @RequestMapping(path="one", method=RequestMethod.GET)
//  public ResponseEntity<String> one() {
//      //子线程异步执行
//      taskService.task1("Tom");
//      taskService.task2("Tom");
//      //主线程返回提前返回数据
//      return ResponseEntity.ok().body("success");
//  }

    @RequestMapping(path = "tow", method = RequestMethod.GET)
    public ResponseEntity<String> tow() {
        //子线程异步执行
        Future<String> task1 = taskFutureService.task1("Tom");
        Future<String> task2 = taskFutureService.task2("Tom");
        //主线程等待返回结果
        while (true) {
            if (task1.isDone() && task2.isDone()) {
                // 三个任务都调用完成，退出循环等待
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        String result = null;
        try {
            result = task1.get() + "..." + task2.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        return ResponseEntity.ok().body(result);
    }
}

2.4 线程池配置

当主线程的线程达到一定程度时候，主线程异步开启的子线程会几何数上涨，为了减少线程打开关闭的开销，所以使用线程池是必须的。

1、线程池的配置

@Bean
public AsyncTaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(8);//核心线程数
    executor.setMaxPoolSize(32);// 最大线程数
    executor.setQueueCapacity(64);//队列最大长度
    executor.setThreadNamePrefix("task-executor");
    
    // rejection-policy：饱和策略，当pool已经达到max size的时候，如何处理新任务
    // 1.CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
    // 2.ABORT_RUNS：默认策略，抛出RejectedExecutionException异常 终止
    // 3.DISCARD_OLDEST_RUNS：当新提交的任务无法保存到队列中等待执行时将抛弃最旧的任务，然后尝试提交新任务
    // 4.DiscardPolicy:不能执行的任务将被丢弃
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    executor.initialize();
    return executor;
}

2、使用线程池。（需要在@Async注解上增加线程池名称）

@Async("taskExecutor")
public void task1(String name) {
    try {
        TimeUnit.SECONDS.sleep(3);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("Hello, " + name);
}