启动一个异步线程去执行一个任务

最新推荐文章于 2024-10-11 09:37:52 发布

下一次是什么时候

最新推荐文章于 2024-10-11 09:37:52 发布

阅读量1.1w

点赞数

分类专栏： spring内置线程池的使用使用异步线程去执行某一个特定的任务多线程编程文章标签：使用异步线程去执行某一个任务

本文链接：https://blog.csdn.net/qq_17089617/article/details/79110922

版权

使用异步线程去执行某一个特定的任务同时被 3 个专栏收录

1 篇文章 0 订阅

订阅专栏

多线程编程

1 篇文章 0 订阅

订阅专栏

spring内置线程池的使用

0 篇文章 0 订阅

订阅专栏

1.业务场景：
 浦发银行充值接口，他行卡充值不是实时将充值结果返回的，需要我们自己去手动去查。银行充值接口实现业务都是预计2小时到账，但如果需求修改发送充值接口后，立马去调用银行提供的状态查询接口，将状态查询回来时，需要启动一个异步线程将结果查询回来.

代码编辑如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
           http://www.springframework.org/schema/aop   
           http://www.springframework.org/schema/aop/spring-aop-3.2.xsd  
           http://www.springframework.org/schema/tx  
           http://www.springframework.org/schema/tx/spring-tx-3.2.xsd  
           http://www.springframework.org/schema/context  
           http://www.springframework.org/schema/context/spring-context-3.2.xsd"
    default-autowire="byName" default-lazy-init="false">

    <!-- 使用spring提供的线程池 -->
    <bean id="executePool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <!-- 线程池维护线程的最小数量 -->
        <property name="corePoolSize" value="1"></property>
        <!-- 线程池维护线程所允许的空闲时间 -->
        <property name="maxPoolSize" value="5"></property>
        <!-- 线程池所使用的最大数量 -->
        <property name="keepAliveSeconds" value="30000" />
        <!-- 线程池所使用的缓冲队列 -->
        <property name="queueCapacity" value="1000" />
    </bean>

    <bean id="asyExecuteService" class="com.adai.asy.service.imp.AsyExecuteServiceImp" destroy-method="destory">
        <property name="executePool"  ref="executePool" />
    </bean>
    
    <context:annotation-config/>
    <context:component-scan base-package="com.adai"/>
</beans>

package com.adai.asy.service;

import java.util.Map;
/**
 * 异步服务接口
 * @author v-chenk25
 * @since 2018-01-19 21:35
 *
 */
public interface AsyExecuteService {
	/**
	 * 异步服务
	 * @param taskId  服务id
	 * @param sendMap 请求参数
	 */
	public void execute(String taskId , Map<String,Object> sendMap);
}

package com.adai.asy.service;

import java.util.Map;

/**
 * 异步接口
 * @author v-chenk25
 * @since 2018-01-19 21:35
 *
 */
public interface AsyService {
	/**
	 * 异步交易接口
	 * @param sendMap 请求参数
	 */
	public void execute(Map<String,Object> sendMap) ;
}

package com.adai.asy.service.imp;

import java.util.Date;
import java.util.Map;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import com.adai.asy.service.AsyExecuteService;
import com.adai.asy.service.AsyService;
import com.adai.constant.Dict;
import com.adai.util.Utils;
/**
 * 异步服务实现类:这里需要注入线程池启动一个线程去执行任务
 * @author v-chenk25
 * @since 2018-01-19 21:35
 */
public  class AsyExecuteServiceImp implements AsyExecuteService , ApplicationContextAware{
	private ApplicationContext context ;
	private ThreadPoolTaskExecutor executePool ;
	public void execute(String taskId, final Map<String, Object> sendMap) {
		sendMap.put(Dict.TASKID, taskId) ;
		final AsyService asyService = (AsyService) this.context.getBean(taskId) ;
		this.executePool.execute(new Runnable() {
			public void run() {
				asyService.execute(sendMap);
			}
		});
		
		
	}
	
	public Map<String,Object> prepareReq(Map<String,Object> sendMap){
		sendMap.put(Dict.ORDERID, Utils.getCurrentFormat(new Date(), Dict.YNRH)) ;
		return sendMap;
	}
	
	public void destory() {
		if(this.executePool != null) {
			this.executePool.shutdown();
		}
	}
	
	public void setApplicationContext(ApplicationContext context) throws BeansException {
		this.context = context ;
	}
	public void setExecutePool(ThreadPoolTaskExecutor executePool) {
		this.executePool = executePool;
	}
	
}

package com.adai.asy.service.imp;

import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.adai.asy.service.AsyService;
import com.adai.constant.Dict;
/**
 * 异步服务接口实现类
 * 这里主要时为了打印每一个任务需要执行的时间，正真执行业务逻辑的方法是executeInnert
 * @author v-chenk25
 *
 */
public abstract class AsyServiceImp implements AsyService{
	private Log log = LogFactory.getLog(AsyServiceImp.class) ;
	public void execute(Map<String,Object> sendMap) {
		long start = System.currentTimeMillis();
		log.info("异步线程开始执行:"+sendMap.get(Dict.TASKID)+"任务");
		executeInnert(sendMap) ;
		long end = System.currentTimeMillis();
		log.info("异步线程执行结束，任务执行时间为:"+(end-start));
	}
	
	/** 真正执行业务逻辑 **/
	public abstract void executeInnert(Map<String,Object> sendMap);
}

package com.adai.asy.service.imp;

import java.util.Map;

import org.springframework.stereotype.Service;

import com.adai.asy.service.AsyService;
/**
 * 需要异步执行任务的具体实现类
 * @author v-chenk25
 *
 */
@Service("myTaskAsyService1")
public class MyTaskAsyServiceImp extends AsyServiceImp implements AsyService  {

	@Override
	public void executeInnert(Map<String, Object> sendMap) {
		//做自己的业务逻辑处理 , 比如发银行的接口，调用dubbo服务
		System.out.println(this.getClass().getName());
		System.out.println(sendMap);
	}


}

package com.adai.constant;
/**
 * 常量字典
 * @author v-chenk25
 *
 */
public class Dict {
	/**交易流水号**/
	public static final String ORDERID = "OrderId" ;
	/** 日期格式 **/
	public static final String YND = "yyyyMMdd" ;
	/**时间戳格式**/
	public static final String YNRH = "yyyyMMdd HH:mm:ss sss" ;
	/**时间格式**/
	public static final String HOUR = "HH:mm:ss" ;
	/**交易id**/
	public static final String TASKID = "taskId" ;
	
}

package com.adai.util;

import java.text.SimpleDateFormat;
import java.util.Date;
/**
 * 工具类
 * @author v-chenk25
 *
 */
public class Utils {
	
	/**当前日期指定格式字符串**/
	public static String getCurrentFormat(Date date ,String format) {
		return new SimpleDateFormat(format).format(date);
	}
}

package com.adai.asy.service.imp;

import java.util.Map;

import org.springframework.stereotype.Service;

import com.adai.asy.service.AsyService;
/**
 * 需要异步执行任务的具体实现类
 * @author v-chenk25
 *
 */
@Service("myTaskAsyService2")
public class MyTaskAsyServiceImp2 extends AsyServiceImp implements AsyService  {

	@Override
	public void executeInnert(Map<String, Object> sendMap) {
		//做自己的业务逻辑处理
		System.out.println(this.getClass().getName());
		System.out.println(sendMap);
	}


}

package com.adai;

import java.util.HashMap;
import java.util.Map;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.adai.asy.service.AsyExecuteService;

public class TestAsy {
	public static void main(String[] args) {
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"classpath:spring-activemq.xml"}) ;
		context.start();
		AsyExecuteService asyService = (AsyExecuteService) context.getBean("asyExecuteService") ;
		for(int i=1 ; i<10 ;i++) {
			Map<String,Object> sendMap = new HashMap<String,Object>() ;
			sendMap.put(i+"", i) ;
			asyService.execute("myTaskAsyService"+1, sendMap);
		}
	}
}

总结：设计思路为：使用一个线程池开启一个线程去执行一个任务，任务id就是spring bean的名字，通ApplicationContextAware 来获取spring容器的bean，然后调用execute方法执行具体的业务逻辑。为了扩展，所以要求需要异步执行的类需要现实统一的接口，也就是AsyService接口。