配合长时间定时任务，立即执行该定时任务的思路

业务场景：

订单支付成功时，订单信息需要给银行系统同步，由于不能保证银行返回信息的时间，所以使用队列进行同步，并且用spring的定时任务执行。

需求：

订单支付成功时立即执行一次同步任务，如果失败，则没半小时执行一次同步任务，直至同步成功。

问题：

spring定时任务定为半小时，订单成功支付时，无法立即执行任务，只能等0-30分钟后执行同步任务，所以需要做一个功能，在订单支付成功的时候，调用一次同步任务。

解决方案：

在服务启动时，初始化一个A线程，该线程每隔N秒扫描一次任务集合，集合中存放着某个任务，扫描到就执行任务。然后在订单支付成功时，在将订单放入队列后，接着将订单放入任务集合，由A线程扫描并执行。

支付成功后代码：

BizLogger.info("订单支付成功！！！");
Singleton.put(SpdbRateTask.class);

Singleton：

import java.util.concurrent.ConcurrentHashMap;

public class Singleton {
	private static ConcurrentHashMap<String,Class> map = new ConcurrentHashMap<String,Class>();
	public static ConcurrentHashMap<String,Class> getMap(){
		return map;
	}
	
	public static void put(Class clazz){
		map.put(clazz.getCanonicalName(), clazz);
	}
}

初始化线程任务：

import java.util.Iterator;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ConcurrentHashMap;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import org.springframework.web.context.support.WebApplicationContextUtils;
import com.jniu.app.task.ExcutTask;
import com.jniu.app.util.Singleton;
import com.jniu.bas.context.Context;
import com.jniu.bas.log4j.logger.BizLogger;

public class ProjectInit implements ServletContextListener {
	private ConcurrentHashMap<String, Class> map = Singleton.getMap();

	/**
	 * 初始化学校缓存
	 */
	@Override
	public void contextInitialized(final ServletContextEvent sce) {
		// 初始化当前上下文
        Context ctx = Context.createContext("currentContext", null);
        Context.pushCurrentContext(ctx);
		TimerTask task = new TimerTask() {
			@Override
			public void run() {
				Iterator<Map.Entry<String, Class>> it = map.entrySet().iterator();
				ExcutTask t = null;
				try {
					Thread.sleep(3000);//任务不多，且不是很频繁，队列使用的是redis的list，为了防止定时任务执行时redis中还没有数据，这里延迟三秒
					while (it.hasNext()) {
						Map.Entry<String, Class> entry = it.next();
						BizLogger.info("项目任务"+entry.getValue().getCanonicalName()+"执行开始");
						t = ((ExcutTask) WebApplicationContextUtils.getWebApplicationContext(sce.getServletContext()).getBean(entry.getValue()));
						t.a();
						BizLogger.info("项目任务"+t.getClass().getCanonicalName()+"执行完成");
						it.remove();
					}
				} catch (Exception e) {
					e.printStackTrace();
					BizLogger.info("项目任务"+t.getClass().getCanonicalName()+"执行失败");
				}
			}
		};
		Timer timer = new Timer();
		long delay = 0;
		long intevalPeriod = 10 * 1000;//每十秒检查一遍任务集合
		timer.scheduleAtFixedRate(task, delay, intevalPeriod);
	}

	/**
	 * 销毁工作
	 */
	@Override
	public void contextDestroyed(ServletContextEvent sce) {
		// TODO Auto-generated method stub
	}
}

spring定时任务：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import com.jniu.app.constans.Constans;
import com.jniu.app.service.SpdbOrderService;
import com.jniu.bas.log4j.logger.BizLogger;
import com.jniu.bas.result.ResultBean;

@Service
public class SpdbRateTask implements ExcutTask{
	@Autowired
	RedisTemplate<String, Object> redisTemplate;
	@Autowired
	SpdbOrderService spdbOrderService;
	
	public void a(){
		String t = null;
		ResultBean resultBean = null;
		try {
			long size = redisTemplate.opsForList().size(Constans.SPDB_RATE_QUEUE);
			if(size>0){
				for(int i=0;i<size;i++){
					t = (String)redisTemplate.opsForList().rightPop(Constans.SPDB_RATE_QUEUE);
					if(t!=null){
						resultBean = spdbOrderService.transDetailObtain(t);
						if(!resultBean.isSuccess()){
							redisTemplate.opsForList().leftPush(Constans.SPDB_RATE_QUEUE, t);
						}
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			if(t!=null)
				redisTemplate.opsForList().leftPush(Constans.SPDB_RATE_QUEUE, t);
			BizLogger.info(resultBean.getMessage());
		}
	}

	@Override
	public String toString() {
		return "SpdbRateTask-----name";
	}
}