使用多线程提高Rest服务性能

⒈使用Runnable异步处理Rest服务

     /**
      *使用Runnable异步处理Rest服务
      * @return
      */
     @GetMapping("/order")
     public Callable<String> callableOrder(){
         logger.info("主线程开始");
         System.out.println(Thread.currentThread().getId());
         Callable<String> result = new Callable<String>() {
             @Override
             public String call() throws Exception {
                 logger.info("副线程开始");
                 Thread.sleep(1000);
                 System.out.println(Thread.currentThread().getId());
                 logger.info("副线程返回");
                 return "seccess";
             }
         };
         logger.info("主线程返回");
         return result;
     }

Runnable的这种形式并不能满足所有的应用场景，使用Runnable异步处理的时候，副线程必须是由主线程调起的，在实际开发的过程中，有些场景是非常复杂的。

例如，如下场景：

我们可以使用DeferredResult来解决上面复杂的场景

⒉使用DeferredResult异步处理Rest服务

　　1.模拟队列

 package cn.coreqi.security.async;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Component;

 /**
  * 用于模拟消息队列
  */
 @Component
 public class MockQueue {

     private String placeOrder;  //代表下单的消息

     private String completeOrder;   //代表订单完成的消息

     private Logger logger = LoggerFactory.getLogger(getClass());

     public String getPlaceOrder() {
         return placeOrder;
     }

     public void setPlaceOrder(String placeOrder){
         new Thread(() -> {
             logger.info("接到下单请求！" + placeOrder);
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             this.completeOrder = placeOrder;
             logger.info("下单请求处理完成！" + placeOrder);
         }).start();
     }

     public String getCompleteOrder() {
         return completeOrder;
     }

     public void setCompleteOrder(String completeOrder) {
         this.completeOrder = completeOrder;
     }
 }

　　2.模拟结果

　　

 package cn.coreqi.security.async;

 import org.springframework.stereotype.Component;
 import org.springframework.web.context.request.async.DeferredResult;

 import java.util.HashMap;
 import java.util.Map;

 @Component
 public class DeferredResultHolder {

     private Map<String, DeferredResult<String>> map = new HashMap<>();  //K为ID，V代表处理结果

     public Map<String, DeferredResult<String>> getMap() {
         return map;
     }

     public void setMap(Map<String, DeferredResult<String>> map) {
         this.map = map;
     }
 }

　　3.控制器处理

     @Autowired
     private MockQueue mockQueue;

     @Autowired
     private DeferredResultHolder deferredResultHolder;

     /**
      * 使用DeferredResult异步处理Rest服务
      * @return
      * @throws InterruptedException
      */
     @GetMapping("/order")
     public DeferredResult<String> deferredResultOrder() throws InterruptedException {
         logger.info("主线程开始");
         System.out.println(Thread.currentThread().getId());
         String orderNumber = new Random().longs(8).toString();  //生成订单号
         mockQueue.setPlaceOrder(orderNumber);   //放入到消息队列里面
         DeferredResult<String> result = new DeferredResult<>();
         deferredResultHolder.getMap().put(orderNumber,result);
         return result;
     }

　　4.监听结果并返回

 package cn.coreqi.security.async;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ApplicationListener;
 import org.springframework.context.event.ContextRefreshedEvent;
 import org.springframework.stereotype.Component;
 import org.springframework.util.StringUtils;

 @Component
 public class QueueListener implements ApplicationListener<ContextRefreshedEvent> {
     @Autowired
     private MockQueue mockQueue;    //模拟的队列
     @Autowired
     private DeferredResultHolder deferredResultHolder;

     private Logger logger = LoggerFactory.getLogger(getClass());
     @Override
     public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
         new Thread(() -> {
             while (true){
                 if(StringUtils.hasText(mockQueue.getCompleteOrder())){
                     String oderNumber = mockQueue.getCompleteOrder();   //拿到订单号
                     logger.info("返回订单处理结果：" + oderNumber);
                     deferredResultHolder.getMap().get(oderNumber).setResult("place order success");
                     mockQueue.setCompleteOrder(null);
                 }else{
                     try {
                         Thread.sleep(100);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }
         }).start();
     }
 }

⒊异步相关配置

 package cn.coreqi.security.config;

 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.servlet.config.annotation.AsyncSupportConfigurer;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

 @Configuration
 public class WebConfig implements WebMvcConfigurer {

     /**
      * 配置异步支持
      * @param configurer
      */
     @Override
     public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
         //configurer.registerCallableInterceptors();  //设置异步的拦截器
         //configurer.registerDeferredResultInterceptors();    //设置异步的拦截器
         //configurer.setDefaultTimeout(20000);  //设置超时时间
         //configurer.setTaskExecutor();   //默认情况下Spring用自己简单的异步线程池来处理，不会重用池里面的线程，
                                         //而是每次调用时都会开启新的线程，可以自己设置一些可重用的线程池来替换
                                         //Spring默认的简单异步线程池。
     }
 }