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

package com.imooc.web.async;

import java.util.concurrent.Callable;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AsyncController {
  
	private Logger logger = LoggerFactory.getLogger(AsyncController.class);
	
	@RequestMapping("/order")
	public String order() throws Exception{
		logger.info("主线程开始");
		Thread.sleep(1000);
		logger.info("主线程返回");
		return "success";
	}
	@RequestMapping("/orderAsy")
	public Callable<String>  orderAsy() throws Exception{
		logger.info("主线程开始");
		Callable<String> result = new Callable<String>() {

			@Override
			public String call() throws Exception {
				logger.info("副线程开始");
				Thread.sleep(1000);
				logger.info("副线程返回");
				return "success";
			}
			
		};
		logger.info("主线程返回");
		return result;
	}
}

结果：

 

多线程后主线程和副线程自己执行自己的代码,从时间上可以看出来。这个是Runnable实现的同步,缺点就是主线程和副线程耦合性太强,副线程依赖于主线程,不适用于两个服务的同步，例如生产消费者模式。为了解决这个问题我们引入了DeferredResult。

package com.imooc.web.async;

import org.apache.commons.lang.RandomStringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.async.DeferredResult;

@RestController
public class AsyncController {
  
	@Autowired
	private MockQueue mockQueue;
	
	@Autowired
	private DeferredResultHolder deferredResultHolder;
	
	private Logger logger = LoggerFactory.getLogger(AsyncController.class);
	
	@RequestMapping("/orderAsy")
	public DeferredResult<String>  orderAsy() throws Exception{
		logger.info("主线程开始");
		
		//生成订单号
		String orderNumber = RandomStringUtils.random(8);
		mockQueue.setPlaceOrder(orderNumber);
		
		DeferredResult<String> result = new DeferredResult<>();
		deferredResultHolder.getMap().put(orderNumber, result);
		
		logger.info("主线程结束");
		return result;
	}
}

package com.imooc.web.async;

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

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

@Component
public class DeferredResultHolder {
  
	private Map<String, DeferredResult<String>> map = new HashMap<String,DeferredResult<String>>();

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

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

package com.imooc.web.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(QueueListener.class);
	
	public String getPlaceOrder() {
		return placeOrder;
	}

	public void setPlaceOrder(String placeOrder) throws InterruptedException {
		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;
	}
	
}

package com.imooc.web.async;

import org.apache.commons.lang.StringUtils;
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;

@Component
public class QueueListener implements ApplicationListener<ContextRefreshedEvent>{
     
	@Autowired
	private MockQueue mockQueue;
	@Autowired
	private DeferredResultHolder deferredResultHolder;
	
	private Logger logger = LoggerFactory.getLogger(QueueListener.class);
	
	@Override//模拟监听
	public void onApplicationEvent(ContextRefreshedEvent event) {
		
		new Thread(()-> {
			while(true) {
				if (StringUtils.isNotBlank(mockQueue.getCompleteOrder())) {
					String orderNumber = mockQueue.getCompleteOrder();
					logger.info("返回订单处理结果集："+orderNumber);
					deferredResultHolder.getMap().get(orderNumber).setResult("place order success");
					mockQueue.setCompleteOrder(null);
				} else {
	                 try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}).start();
	}
   
}

 

结果：

针对同步interceptor的配置和普通的配置不一样：（分别对应上边的两种同步方式）