使用多线程提高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默认的简单异步线程池。
    }
}