用心Coding之一spring中的多线程应用以及对象的autowared

记录一次自己的代码优化历程，希望对大家有所帮助。

项目背景：系统A（可能多个）将自己收集到的数据传送给系统B，系统B接收后进行业务处理

项目要求：低延迟，高效率

采用协议：hession协议

开发过程中总共经历了三个开发者，对此做如下记录也激励自己写出更加优美的代码。

1.开发者A的思路和过程（第一次项目代码）

1.1设计思路和实现

通过在hession实现类中定义static 属性的List的对象保存收到的数据，再通过线程循环处理。

@Service
@Transactional 
public class HessianServiceImpl implements HessianService {
	//入口List
	public  static List<EriInfo> eriInEnterfoList = new LinkedList<EriInfo>();
	@Override
	public void setEriInfo(EriInfo eriInfo){
		eriInEnterfoList.add(eriInfo);
	}
}

线程处理

public class EnterThread extends Thread {	
	private BmdcxService bmdcxService;
	// 上下文事件
	private ServletContextEvent event = InitThread.event;
	WebApplicationContext context = WebApplicationContextUtils.getRequiredWebApplicationContext(event.getServletContext());
	@Override
	public void run() {
		bmdcxService = (BmdcxService) context.getBean("bmdcxService");
		while (true) {
			System.console();
			if (HessianServiceImpl.eriInEnterfoList.size() > 0) {
				EriInfo eriInfo = HessianServiceImpl.eriInEnterfoList.get(0);
				if (eriInfo != null) {
					String carPlateo = eriInfo.getPlateNo();
					// 查询处理
					 bmdcxService.queryByplateno(carPlateo, "0");
				}
			}
		}
	}
}

业务可以跑起来，没毛病。

1.2问题归纳

单线程

服务注册方式太丑陋

数据丢失（debuge调试时发生数据丢失，可能是线程调用问题。自己调查发现System.console();可以解决。一直心存疑问）

2.开发者B的思路和过程（第一次优化）

功能实现，可是使用spring的优势一点都没有体现出来，决心优化一次。

优化点：

使用消费者生产者模式做数据接收处理，避免上面的低效率问题。

使用spring的注解，进行对象的引用

2.1实现代码

定义阻塞队列，先将数据放入队列，再通过多线程进行处理。

hession接口实现，将数据塞入队列中

@Service
@Transactional 
public class HessianServiceImpl implements HessianService {
	
	@Override
	public void setEriInfo(EriInfo eriInfo) throws InterruptedException {
		EriInfoQueue.getEriInfoQueue().produce(eriInfo);
		
	}
}

消息队列定义

public class EriInfoQueue {
	//队列大小
    static final int QUEUE_MAX_SIZE   = 1000000;

    static BlockingQueue<EriInfo> blockingQueue = new LinkedBlockingQueue<EriInfo>(QUEUE_MAX_SIZE);
    
    /**
     * 私有的默认构造子，保证外界无法直接实例化
     */
    
    private EriInfoQueue(){};
    
    
    /**
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
     */
    private static class SingletonHolder{
    	
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private  static EriInfoQueue queue = new EriInfoQueue();
    }
    
    //单例队列
    public static EriInfoQueue getEriInfoQueue(){
        return SingletonHolder.queue;
    }
    
    //生产入队
    public  void  produce(EriInfo eriInfo) throws InterruptedException {
        blockingQueue.put(eriInfo);
    }
    
    //消费出队
    public  EriInfo consume() throws InterruptedException {
        return blockingQueue.take();
    }
    
    // 获取队列大小
    public int size() {
        return blockingQueue.size();
    }
}

生产者定义

@Component
public class ConsumeEriInfoQueue {

	private static final Logger logger = LoggerFactory.getLogger(ConsumeEriInfoQueue.class);
	@Autowired //对象注入
	public YxsjService yxsjService ;
	
	@PostConstruct
	    public void startThread() {
	        ExecutorService e = Executors.newFixedThreadPool(2);// 两个大小的固定线程池
	        e.submit(new PollEriInfo(yxsjService));//缺点1 引用的对象放到了构造方法中
	        e.submit(new PollEriInfo(yxsjService));
	    }
	 @PreDestroy
	    public void stopThread() {
	        logger.info("destroy");
	    }
}

具体实现类

public class PollEriInfo implements Runnable {
	
	private static final Logger logger = LoggerFactory
			.getLogger(PollEriInfo.class);

	public YxsjService yxsjService ;
	
	 public PollEriInfo(YxsjService yxsjService) {
         this.yxsjService = yxsjService;
     }
			
	@Override
	public void run() {
		while (true) {
			try {
				EriInfo eriInfo = EriInfoQueue.getEriInfoQueue().consume();
		          	if (eriInfo != null) {
					yxsjService.saveYxsj(yxsjInfo);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

2.2问题归纳

引用的对象写到了构造方法中，如果引用对象太多是个问题（需要定义一个总的接口）。

3.开发者C的再次优化

优化思路：使用spring的Async注解，将对象autowared注入再次优化

线程池配置

@Configuration
@EnableAsync
public class TaskExecutorConfig implements AsyncConfigurer{

	@Override
	public Executor getAsyncExecutor() {
		ThreadPoolTaskExecutor taskExecutor =  new ThreadPoolTaskExecutor();
		taskExecutor.setCorePoolSize(5);
		taskExecutor.setMaxPoolSize(10);
		taskExecutor.setQueueCapacity(200);
		taskExecutor.setThreadNamePrefix("receiveRFID");
		taskExecutor.initialize();
		return taskExecutor;
	}

	@Override
	public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
		return null;
	}

}

hession接口实现

@Service
@Transactional 
public class HessianServiceImpl implements HessianService {

	@Autowired 
	ReceiveRFIDService receiveRFIDService;
	@Override
	public void setEriInfo(EriInfo eriInfo) throws InterruptedException {
		receiveRFIDService.receiveRFID(eriInfo);
	}

}

重点来了，数据处理服务类

@Service
public class ReceiveRFIDService{
	

    @autowared //对象的注入，看不出差别
    private IInstallInfoService installInfoService;

    @Async("receiveRFID") 
	public void receiveRFID(EriInfo eriInfo) {
		 installInfoService.recordInstallInfo(installInfo);
	}
}

记录一段代码的优化过程，希望给大家有所启发。