线程池的应用（十三）

一、项目中对于线程池的应用

1、通过上一章，我们可以看到，最简单的线程池是如何创建，如何执行的。execute（）里的参数是一个继承Thread类或实现了Runnable接口的线程。需要用到线程池的逻辑是放在这个线程的run()方法里的。例如第一个例子中，通过for循环，创建了20000个线程，这20000个线程通过线程池来执行，线程越多，run()方法里需要处理的逻辑越复杂，数据量越大，越能体现线程池的效率。

2、上面可能说的有点乱，但是整体的意思就是说明在哪里用到了线程池及为什么要用线程池。

3、下面通过准备金系统具体的例子来说明对线程池的应用。

二、A系统的佣兵*方法

2.1 前言

A系统的佣兵*任务执行工具，就是针对线程池，开发出来的一套多线程执行工具

2.2 佣兵

package com.asd.common.mission.mercenary;

import com.asd.common.mission.methodHandler.MethodManager;
import com.asd.common.mission.mission.Mission;
import com.asd.common.mission.missionHandler.MissionHandleListener;
import com.asd.common.mission.missionHandler.MissionHandlerAOP;

/**
 * 佣兵
 * @author 69420
 *
 */
public class Mercenary implements Runnable{
    private MethodManager methodManager;
    private String methodName;
    private Mission mission;
    private MissionHandlerAOP handlerAOP;
    private MissionHandleListener missionHandleListener;
    
    /**
     * @param methodManager 处理工具
     * @param handlerAOP 切面方法
     * @param missionHandleListener 监听器
     * @param methodName 处理方法 
     * @param mission 任务
     */
    public Mercenary(MethodManager methodManager,
                     MissionHandlerAOP handlerAOP,
                     MissionHandleListener missionHandleListener,
                     String methodName,Mission mission) {
        this.methodManager = methodManager;
        this.handlerAOP = handlerAOP;
        this.missionHandleListener = missionHandleListener;
        this.methodName = methodName;
        this.mission = mission;
    }
    
    public void run() {
        try {
            if(handlerAOP!=null){
                handlerAOP.handleBefore(mission);
            }
            if(missionHandleListener!=null){
                missionHandleListener.handleBefore(mission);
            }
            execute();
            if(handlerAOP!=null){
                handlerAOP.handleAfter(mission);
            }
            if(missionHandleListener!=null){
                missionHandleListener.handleAfter(mission);
            }
        } catch (Exception e) {
            e.printStackTrace();
            if(handlerAOP!=null){
                handlerAOP.handleException(mission,e);
            }
            if(missionHandleListener!=null){
                missionHandleListener.handleException(mission,e);
            }
        }
    }
    
    /**
     * 执行一个任务
     * @throws Exception
     */
    public void execute() throws Exception{
        methodManager.execute(methodName, mission);
    }
      
}

1、佣兵，意思很浅显，就是用来干活的。

这个佣兵其实就相当于上一章中的如下图标红处的代码。在A系统的多线程工具中，单独抽取取来，封装了一个佣兵类多线程，因为在实际的程序里，业务逻辑一定会特别复杂，只用好的封装，才更有复用性。

2、可以看到，这个多线程类中，任务（方法名）是当作参数传进来的。这就体现了封装的好处，将一切逻辑相关的东西，都封装在了任务里，下面会对任务进行详细说明。

3、这个方法里封装了通过反射执行方法的代码，见标蓝的代码。这里的任务均指的需要通过线程池来执行的方法，下面不再进行说明。

还可以看到，任务执行前后的切面方法与监听，都是在这里调用的，这里不对监听和切面方法做重点说明了。

4、方法经理

package com.asd.common.mission.methodHandler;



public class MethodManagerFactory {
    /**
     * 获取方法管理工具
     * @param handler
     * @return
     */
    public static MethodManager getMethodManager(Handler handler){
        MethodManager mm = new MethodManager();
        mm.init(handler);
        return mm;
    }
    
    
}

package com.asd.common.mission.methodHandler;

import com.asd.common.utils.method.MethodUtils;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class MethodManager {
    private Map<String, Method> methodMap = null;
    private Handler handler;
    /**
     * 初始化
     * @param handler
     */
    public void init(Handler handler){
        this.handler = handler;
        List<Method> methodList = MethodUtils.getMethods(handler);
        methodMap = new HashMap<String, Method>();
        for (Method method : methodList) {
            if(method.isAnnotationPresent(MethodHandler.class)){
                //System.out.println(method.getAnnotation(MethodHandler.class).value());
                methodMap.put(method.getAnnotation(MethodHandler.class).value(), 
                        method);
            }
        }
    }
    /**
     * 执行一个方法
     * @param channel 订阅号
     * @param param 参数
     */
    public void execute(String channel, Object... param) throws Exception{
        if(methodMap==null){
            return;
        }
        Method mt = methodMap.get(channel);
        MethodUtils.executeMethod(handler, mt, param);
    }
}

方法工具类

package com.asd.common.utils.method;

import com.asd.common.utils.object.ClassUtils;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;


/** 方法工具,通过反射操作方法,均为静态调用
 * 
 * @author lmaos 
 * 2016年11月14日 上午10:50:12
 */
public class MethodUtils {
    /** 方法缓存 初始时申请128长度,保证允许更多的线程同时访问
     * 
     */
    protected static Map<Class, Map<String,Method>> methodCache = new ConcurrentHashMap<Class, Map<String,Method>>(128);
    private static Object MethodCacheLock = new Object();
    
    /** 生成一个方法的key
     * 
     * @param method
     * @return
     */
    public static String getMethodKey(Method method){
        String key = getMethodKey(method.getName(), method.getParameterTypes());
        return key;
    }
    
    /** 生成一个方法的key
     * 
     * @param method
     * @param params
     * @return
     */
    public static String getMethodKey(String method,Class... params){
        StringBuffer key_buf = new StringBuffer(method);
        if(params!=null&&params.length>0){
            for (Class param : params) {
                key_buf.append(param.hashCode()).append(",");    // 通过hashcode确定方法key。
//                key_buf.append(param.getName()).append(",");    // 通过方法名确定方法key。
            }
            key_buf.replace(key_buf.length()-1, key_buf.length(), "");
        }
        String key = key_buf.toString();
        return key;
    }
    /** 添加一个方法的缓存。。
     * 
     * @param clazz
     * @param method
     * @param replace 如果true 则如果存在这个key指向的方法则替换。如果false 则不替换
     */
    public static void addMethodCache(Class clazz,Method method){
        
        Map<String,Method> subMethodCache = methodCache.get(clazz); // 获取这个子缓存
        if(subMethodCache == null){
            synchronized (MethodCacheLock) {                        // 此处同步不会有第二个线程同时操作
                subMethodCache = methodCache.get(clazz);                
                if(subMethodCache == null){                             // 确定缓存不存在
                    subMethodCache = new HashMap<String,Method>();
                    methodCache.put(clazz, subMethodCache);
                }
            }
        }
        String key = getMethodKey(method);
        if(!subMethodCache.containsKey(key)){
            subMethodCache.put(key, method);
        }
    }
    
    /** 从缓存获取当前方法
     * 
     * @param clazz
     * @param name
     * @param params 携带参数类型
     * @return
     */
    protected static Method getMethodByCache(Class clazz, String name, Class... params){
        Map<String,Method> subMethodCache = methodCache.get(clazz); // 获取这个子缓存
        Method method = null;
        if(subMethodCache!=null){
            method = subMethodCache.get(getMethodKey(name, params));
        }
        return method;
    }
    
    protected static List<Method> getMethodsByCache(Class clazz){
        Map<String,Method> subMethodCache = methodCache.get(clazz); // 获取这个子缓存
        List<Method> methods = new ArrayList<Method>();
        if(subMethodCache!=null){
            methods.addAll(subMethodCache.values());
        }
        return methods;
    }
    
    
    
    // 加载方法到同步锁,多线程时候线程安全
    protected final static Object loadMethodsLock = new Object();
    /** 加载全部都方法到缓存中。
     * 
     * @param clazz
     */
    public static void loadAllMethods(Class clazz,boolean replace){
        synchronized (loadMethodsLock) {
            
            /* *********************************************************** *
             * 如果不存在当前缓存，则首先查询当前类所有继承的类。
             * 得到所有继承的类后装载所有放假,会从子类一直加载到继承的父类上。
             * *********************************************************** */
            if(!methodCache.containsKey(clazz)){
                Map<String,Method> subMethodCache = new HashMap<String, Method>();
                List<Class> classs = ClassUtils.getClassAll(clazz, false);
                for (Class cl : classs) {
                    Method[] methods = cl.getDeclaredMethods();
                    for (Method method : methods) {
                        method.setAccessible(true); // 设置访问权限,设置为true 则可以对这个方法非法修改与访问
                        String key = getMethodKey(method);
                        if(!subMethodCache.containsKey(key)){
                            subMethodCache.put(key, method);
                        }
//                            addMethodCache(clazz, method);
                    }
                } // for-end
                methodCache.put(clazz, subMethodCache);
            }else if(replace){ // 替换操作
                
                Map<String,Method> subMethodCache = new HashMap<String,Method>();
                
                List<Class> classs = ClassUtils.getClassAll(clazz, true);
                for (Class cl : classs) {
                    Method[] methods = cl.getDeclaredMethods();
                    for (Method method : methods) {
                        String key = method.getName();
                        method.setAccessible(true); // 设置访问权限,设置为true 则可以对这个字段非法修改与访问
                        subMethodCache.put(key, method);
                    }
                } // for-end
                methodCache.put(clazz, subMethodCache);    //替换方法缓存
            }
        }
    }
    
    /** 加载全部都方法到缓存中。
     * 
     * @param clazz
     */
    public static void loadAllMethods(Class clazz){
        loadAllMethods(clazz, false);
    }


    
    
    
    
    
    
    /** 获取方法
     * 
     * @param clazz
     * @param name
     * @return
     */
    public static Method getMethod(Class clazz,String name, Class... params){
        
        if(!methodCache.containsKey(clazz)){
            loadAllMethods(clazz);
        }
        
        Method method = getMethodByCache(clazz, name, params);
        return method;
    }
    
    /** 获取当前对象中这个方法当对象
     * 
     * @param obj
     * @param name
     * @return
     */
    public static Method getMethod(Object obj,String name, Class... params){
        Class clazz = obj.getClass();
        Method method = getMethod(clazz, name, params);
        return method;
    }
    
    public static List<Method> getMethods(Object obj){
        return getMethods(obj.getClass());
    }
    /** 获取全部都方法
     * 
     * @param clazz
     * @return
     */
    public static List<Method> getMethods(Class clazz){
        if(!methodCache.containsKey(clazz)){
            loadAllMethods(clazz);
        }
        return getMethodsByCache(clazz);
    }
    public static Map<String, Method> getMethodsToMap(Object obj){
        return getMethodsToMap(obj.getClass());
    }
    
    /** 获取这些方法集合，map结构
     * 
     * @param clazz
     * @return
     */
    public static Map<String, Method> getMethodsToMap(Class clazz){
        if(!methodCache.containsKey(clazz)){
            loadAllMethods(clazz);
        }
        Map<String,Method> subMethodCache = methodCache.get(clazz); // 获取这个子缓存
        if(subMethodCache==null){
            return new HashMap<String,Method>();
        }
        return new HashMap<String,Method>(subMethodCache);
    }
    /** 执行这个方法
     * 
     * @param obj
     * @param name            方法名称
     * @param clparam        方法中参数类型集合
     * @param valparams        参数类型对应的传餐
     * @return
     * @throws Exception
     */
    public static Object executeMethod(Object obj, String name,Class[] clparam,Object[] valparams) throws Exception{
        Method method = getMethod(obj, name, clparam);
        return executeMethod(obj, method, valparams);
    }
    
    /**
     * 
     * @param obj
     * @param method        要执行的方法
     * @param valparams        方法中参数
     * @return
     * @throws Exception
     */
    public static Object executeMethod(Object obj, Method method,Object... valparams) throws Exception{
        if(method == null){
            System.err.println("传入方法为null");
            throw new Exception();
            //return null;
        }
        if(!method.isAccessible()){
            method.setAccessible(true);
        }
        return method.invoke(obj, valparams);
    }
    /** 查询被这些注解修饰到方法
     * 
     * @param clazz
     * @param annotationClasss
     * @return
     */
    public static List<Method> indexMethodByAnnotation(Class clazz,Class... annotationClasss){
        if(annotationClasss == null || annotationClasss .length == 0){
            return getMethods(clazz);
        }
        /* ****************************************************** *
         * 结果集合储存查询的被这些注解修饰当方法。
         * 先查询出所有方法，然后一条一条匹配注解。
         * ***************************************************** */
        List<Method> resultMethods = new ArrayList<Method>();
        List<Method> cacheMethods = getMethods(clazz);
        for (Method method : cacheMethods) {
            for (Class annotationClass : annotationClasss) {
                if(method.isAnnotationPresent(annotationClass)){
                    resultMethods.add(method);
                    break;
                }
            }
            
        }
        return resultMethods;
    }
    
    
    /** 查询方法名称为指定名称结束的
     * 
     * @param clazz
     * @param end
     * @return
     */
    public static List<Method> indexMethodByEndText(Class clazz,String end){
        if(end == null || "".equals(end)){
            return getMethods(clazz);
        }
        /* ****************************************************** *
         * 结果集合储存查询的方法名为end结束。
         * ***************************************************** */
        List<Method> cacheMethods = getMethods(clazz);
        List<Method> resultMethods = new ArrayList<Method>();    // 结果
        for (Method Method : cacheMethods) {
            if(Method.getName().endsWith(end)){
                resultMethods.add(Method);
            }
            
        }
        return resultMethods;
    }
    
    /** 查询方法名称包含指定的内容的所有方法
     * 
     * @param clazz
     * @param include 包含的内容
     * @return
     */
    public static List<Method> indexMethodByIncludeText(Class clazz,String include){
        if(include == null || "".equals(include)){
            return getMethods(clazz);
        }
        /* ****************************************************** *
         * 结果集合储存查询的方法名包含include
         * ***************************************************** */
        List<Method> cacheMethods = getMethods(clazz);
        List<Method> resultMethods = new ArrayList<Method>();    // 结果
        for (Method Method : cacheMethods) {
            if(Method.getName().indexOf(include)!=-1){
                resultMethods.add(Method);
            }
            
        }
        return resultMethods;
    }
    

}

方法经理是在创建佣兵*对象时实例化的，在佣兵*中标蓝色。

可以看出，在实例化方法经理时，入参是Handler（任务）接口，任务（方法）都会实现该接口，这也是为什么所有的任务都实现这个接口的原因（这里就体现了多态的好处）。我们要执行的每个任务都不可能一样，通过多态，以父类当作入参，保证不同的任务都可以在这里进行可以初始化。

2.3 佣兵*

package com.asd.common.mission.mercenary;

import com.asd.common.mission.methodHandler.Handler;
import com.asd.common.mission.methodHandler.MethodManager;
import com.asd.common.mission.methodHandler.MethodManagerFactory;
import com.asd.common.mission.mission.Mission;
import com.asd.common.mission.mission.MissionPakage;
import com.asd.common.mission.mission.MissionRecord;
import com.asd.common.mission.missionHandler.MissionHandleListener;
import com.asd.common.mission.missionHandler.MissionHandlerAOP;
import com.asd.common.mission.missionHandler.MissionHandlerAOPImpl;
import com.asd.common.utils.random.RandomUtils;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 佣兵*
 * @author 69420
 *
 */
public class MercenaryGroup {
	/**
	 * 佣兵*ID
	 */
	private String groupId;
	/**
	 * 任务执行器
	 */
	private MethodManager methodManager = null;
	/**
	 * 线程池
	 */
	private ThreadPoolExecutor pool = null;
	/**
	 * 线程池等待队列
	 */
	private LinkedBlockingQueue<Runnable> workQueue = null;
	/**
	 * 任务记录
	 */
	private MissionRecord missionRecord = new MissionRecord();
	/**
	 * 任务处理切面方法
	 */
	private MissionHandlerAOP handlerAOP = new MissionHandlerAOPImpl(missionRecord);
	/**
	 * 任务处理监听方法
	 */
	private MissionHandleListener missionHandleListener = null;
	/**
	 * 创建一个有mercenarySize个佣兵的佣兵*
	 * @param handler  佣兵*处理工具
	 * @param mercenarySize 佣兵*大小
	 * @param waitingSize 阻塞队列大小，如果为-1则大小无上限
	 * @param missionHandleListener 任务监听方法
	 */
	public MercenaryGroup(Handler handler,
						  int mercenarySize, int waitingSize,
						  MissionHandleListener missionHandleListener) {
		this.groupId = RandomUtils.getUniqueId();
		this.methodManager = MethodManagerFactory.getMethodManager(handler);
		if(waitingSize <= 0){
			this.workQueue = new LinkedBlockingQueue<Runnable>();
		}else{
			this.workQueue = new LinkedBlockingQueue<Runnable>(waitingSize);
		}
		if(missionHandleListener!=null){
			this.missionHandleListener = missionHandleListener;
		}
		this.pool = new ThreadPoolExecutor(mercenarySize, mercenarySize, 0, TimeUnit.SECONDS, workQueue,
				new RejectedExecutionHandler() {
			public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
				try {
					executor.getQueue().put(r);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
	}
	/**
	 * 创建一个有mercenarySize个佣兵的佣兵*
	 * @param groupId 佣兵*ID
	 * @param handler  佣兵*处理工具
	 * @param mercenarySize 佣兵*大小
	 * @param waitingSize 阻塞队列大小，如果为-1则大小无上限
	 * @param missionHandleListener 任务包切面工具
	 */
	public MercenaryGroup(String groupId, Handler handler,
						  int mercenarySize, int waitingSize,
						  MissionHandleListener missionHandleListener) {
		this.groupId = groupId;
		this.methodManager = MethodManagerFactory.getMethodManager(handler);
		if(waitingSize == -1){
			this.workQueue = new LinkedBlockingQueue<Runnable>();
		}else{
			this.workQueue = new LinkedBlockingQueue<Runnable>(waitingSize);
		}
		if(missionHandleListener!=null){
			this.missionHandleListener = missionHandleListener;
		}
		this.pool = new ThreadPoolExecutor(mercenarySize, mercenarySize, 5, TimeUnit.SECONDS, workQueue,
				new RejectedExecutionHandler() {
			public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
				try {
					executor.getQueue().put(r);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
	}
	/**
	 * 执行一个任务
	 * @param methodChannel 执行任务的方法名称
	 * @param mission 任务包
	 * @throws Exception
	 */
	public void execute(String methodChannel, Mission mission){
		if(mission == null || methodChannel == null){
			return;
		}
		missionRecord.loadMission(mission);
		this.pool.execute(new Mercenary(methodManager,
				handlerAOP,
				missionHandleListener,
				methodChannel, mission));
	}
	/**
	 * 执行一个任务
	 * @param methodChannel 执行任务的方法名称
	 * @param missionPakage 任务包
	 * @throws Exception
	 */
	public void execute(String methodChannel, MissionPakage missionPakage){
		if(missionPakage == null || methodChannel == null){
			return;
		}
		missionRecord.loadMissionPakage(missionPakage);
		while(missionPakage.hasNext()){
			this.pool.execute(new Mercenary(methodManager,
					handlerAOP,
					missionHandleListener,
					methodChannel, missionPakage.get()));
		}
	}
	/**
	 * 获取佣兵*ID
	 * @return
	 */
	public String getGroupId() {
		return groupId;
	}
	/**
	 * 佣兵*大小
	 * @return
	 */
	public int groupSize(){
		return pool.getMaximumPoolSize();
	}
	/**
	 * 任务包是否完成
	 * @param missionPakageId
	 * @return
	 */
	public boolean isComplete(String missionPakageId){
		return missionRecord.isComplete(missionPakageId);
	}
	/**
	 * 任务包是否完成
	 * @param missionPakageIds
	 * @return
	 */
	public boolean isComplete(String... missionPakageIds){
		boolean is = true;
		for (int i = 0; i < missionPakageIds.length; i++) {
			is = is && missionRecord.isComplete(missionPakageIds[i]);
		}
		return is;
	}
	
	/**
	 * 等待任务包完成
	 * @param missionPakageIds
	 */
	public void waitForComplete(String... missionPakageIds){
		if(missionPakageIds!=null){
			while(!isComplete(missionPakageIds)){
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
	/**
	 * 等待死亡，如果规定时间内无任务进入也无任务完成/发生异常，则认为死亡
	 * @param timeout
	 */
	public void waitForDead(long timeout){
		missionRecord.setHeartBeat(timeout);
		while(!missionRecord.isDead()){
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	/**
	 * 销毁拥兵组
	 */
	public void destory(){
		this.methodManager = null;
		this.missionRecord = null;
		this.handlerAOP = null;
		this.missionHandleListener = null;
		this.pool.shutdown();
		this.pool = null;
	}
}

2.4 任务（方法）及任务（方法）参数对象

2.4.1 方法接口

package com.asd.common.mission.methodHandler;

public interface Handler {
    
}

2.4.2 方法接口

package com.asd.common.mission.missionHandler;


import com.asd.common.mission.methodHandler.Handler;

/**
 * 
 * 任务处理方法接口，只需要实现该接口，自定义方法，用MehtodHandler注释，即可使用
 * 所有方法默认参数有且仅有一个参数：Mission
 * @author 69420
 *
 */
public interface MissionHandler extends Handler {
    
}

2.4.3 方法

在这里编写业务逻辑。

package com.asd.common.mission.missionHandler;

import com.asd.common.mission.methodHandler.MethodHandler;
import com.asd.common.mission.mission.Mission;

public class DemoHandler implements MissionHandler {
    @MethodHandler("default")
    public void run(Mission mission){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我进来了"+mission.getId());
    }
}

2.4.4 任务对象

任务对象用来封装方法的参数信息

package com.asd.common.mission.mission;

import com.asd.common.utils.random.RandomUtils;
import com.asd.common.utils.string.StringUtils;

import java.util.HashMap;
import java.util.Map;
/**
 * 任务对象
 * @author 69420
 *
 */
public class Mission extends HashMap<String, Object>{
    private static final long serialVersionUID = 2903723764002940136L;
    /**
     * 任务ID
     */
    private String id;
    /**
     * 任务包ID
     */
    private String pakageId;
    /**
     * 订阅号
     */
    private String channel = null;
    /**
     * 任务内容
     */
    private Object content = null;
    
    
    public Mission() {
        id = RandomUtils.getUniqueId();
    }
    public Mission(String id) {
        this.id = id;
    }
    
    /**
     * 获取任务ID
     * @return
     */
    public String getId() {
        return id;
    }
    /**
     * 获取任务包ID
     * @return
     */
    public String getPakageId() {
        return pakageId;
    }
    /**
     * 设置任务包ID
     * @param pakageId
     */
    public void setPakageId(String pakageId) {
        this.pakageId = pakageId;
    }
    
    
    /**
     * 获取任务开始位置
     * @return
     */
    public int getStartPosition() {
        return Integer.parseInt(get(id+"-startPosition").toString());
    }
    /**
     * 设置任务开始位置
     * @param startPosition
     */
    public void setStartPosition(int startPosition) {
        put(id+"-startPosition", startPosition);
    }
    
    
    /**
     * 获取任务大小
     * @return
     */
    public int getMissionSize() {
        return Integer.parseInt(get(id+"-missionSize").toString());
    }
    /**
     * 设置任务大小
     * @param missionSize
     */
    public void setMissionSize(int missionSize) {
        put(id+"-missionSize", missionSize);
    }
    
    
    /**
     * 获取订阅号
     * @return
     */
    public String getChannel() {
        return channel;
    }
    /**
     * 设置订阅号
     * @param channel
     */
    public void setChannel(String channel) {
        this.channel = channel;
    }
    
    public void setMissionParams(Map<String, Object> map){
        if(map!=null){
            for (String key : map.keySet()) {
                put(key, map.get(key));
            }
        }
    }
    public void setMissionParams(String jsonObj){
        setMissionParams(StringUtils.jsonToMap(jsonObj));
    }

    public void setContent(Object content) {
        this.content = content;
    }

    public Object getContent() {
        return content;
    }
}

2.5 调用

package com.asd.common.mission.demo;

import com.asd.common.mission.mercenary.MercenaryGroup;
import com.asd.common.mission.mission.Mission;
import com.asd.common.mission.mission.MissionPakage;
import com.asd.common.mission.missionHandler.DemoHandler;
import com.asd.common.mission.missionHandler.DemoListenner;

import java.util.ArrayList;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        demo2();
    }

    /**
    *@Author: MrZs on 2020/3/31 17:03
    *@params: 
    *@return: 
    *@Description:
    */
    public static void demo1(){
        // 创建任务执行佣兵*
        MercenaryGroup mercenaryGroup =
                new MercenaryGroup(new DemoHandler(),
                        10,
                        1,
                        new DemoListenner());
        // 组装任务对象
        List<Mission> missions = new ArrayList<Mission>();
        for (int i = 0; i < 10; i++) {
            Mission mission = new Mission();
            missions.add(mission);
        }
        // 组装任务包
        String missionPakageId = "defaultPakage";
        MissionPakage pakage = new MissionPakage(missionPakageId,missions);
        // 指定佣兵*执行任务包
        String chanel = "default";
        mercenaryGroup.execute(chanel,pakage);
        // 等待任务包执行完毕
        mercenaryGroup.waitForComplete(missionPakageId);
        System.out.println("任务执行完毕");
        // 佣兵*销毁
        mercenaryGroup.destory();
    }

    /**
    *@Author: MrZs on 2020/3/31 16:56
    *@params: 
    *@return: 
    *@Description:这个demo里说明了有多个请求时，是如何调用线程池的
     * 首先，创建佣兵*MercenaryGroup实例，来创建了一个线程池的实例。
     * 下面通过多线程，模拟多个请求，针对每一个请求（即一个线程），都会通过上面的
     * 线程池去执行任务
     * 
    */
    public static void demo2(){
        // 创建任务执行佣兵*
        final MercenaryGroup mercenaryGroup =
                new MercenaryGroup(new DemoHandler(),
                        10,
                        1,
                        new DemoListenner());
        // 指定佣兵*执行任务
        final String chanel = "default";
        mercenaryGroup.execute(chanel,new Mission());
        // 等待任务包执行完毕
        Thread th = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    mercenaryGroup.execute(chanel,new Mission());
                }
            }
        });
        th.start();
        System.out.println("开始等待死亡");
        mercenaryGroup.waitForDead(10000);
        System.out.println("已死亡");
        // 佣兵*销毁
        mercenaryGroup.destory();
    }
}

可以看出，demo1通过循环，创建了十个相同任务对象，将这十个任务进行打包，封装到一个任务包中。调用佣兵*时，会对这个任务包进行循环，一个一个的调用线程池。跟上一个章节的线程池例子一样。mission的作用就是封装每个任务的参数。

 而demo2，是通过循环创建了十个线程。相当于十次请求（十个线程），这十个线程共用了一个线程池实例。

重点说明：

业务系统向准备金系统土司推送数据，用的是demo1。

准备金系统从业务系统同步数据的方法是用多线程来写的。通过异步同步方法，利用多线程，实现的即异步同步数据：同一时点，多次送数，会有多个线程，（相当于demo2）互不干涉的同时进行数据同步。通过继承Thread类，数据不共享。

在每个线程任务里，又用到了线程池。每五十条数，发送执行一次任务。

佣兵*对象是在多线程类中创建的，所以每次推送数据用的不是一个线程池。

多线程类：

class SynoInterfaceData extends Thread{
    private InterfaceLogService interfaceLogService;
    private DataDictionaryService dataDictionaryService;

    public static final Logger log = LoggerFactory.getLogger(ReinsHttpServletController.class);
    private String startDate;
    private String endDate;
    private boolean backdoorFlag = false;
    public SynoInterfaceData(InterfaceLogService interfaceLogService,
                             DataDictionaryService dataDictionaryService,
                             String startDate,String endDate,
                             boolean backdoorflag){
        this.interfaceLogService = interfaceLogService;
        this.dataDictionaryService = dataDictionaryService;
        this.startDate = startDate;
        this.endDate = endDate;
        this.backdoorFlag = backdoorflag;
    }
    @Override
    public void run(){
        Connection conn = null;
        Statement stmt = null;
        String status = "SUCCESS";
        String requestString =  "";
        ResourceBundle interfaceAddress = ResourceBundle.getBundle("interfaceAddress");
        try{
            log.info("准备金抽取数据开启数据库连接开始");
            conn = ConnectionUtil.openConnect();
            log.info("准备金抽取数据开启数据库连接开始");
            ConnectionUtil.beginTransaction(conn);
            Map<String,String> tableMap = new HashMap<String,String>(){
                {
                    put("ZRJOUTSTANDINGACC","com.asd.modules.pojo.zrjoutstandingacc.model.Zrjoutstandingacc");
                    put("ZRJOUTSTANDINGFAC","com.asd.modules.pojo.zrjoutstandingfac.Zrjoutstandingfac");
                    put("ZRJOUTSTANDINGTREATY","com.asd.modules.pojo.zrjoutstandingtreaty.Zrjoutstandingtreaty");
                    put("ZRJUNEARNEDACC","com.asd.modules.pojo.zrjunearnedacc.model.Zrjunearnedacc");
                    put("ZRJUNEARNEDFAC","com.asd.modules.pojo.zrjunearnedfac.model.Zrjunearnedfac");
                    put("ZRJUNEARNEDTREATY","com.asd.modules.pojo.zrjunearnedtreaty.model.Zrjunearnedtreaty");
                }
            };

            stmt = conn.createStatement();
            //先删除对应日结日期的数据
            for (String table:tableMap.keySet()){
                stmt.addBatch("DELETE FROM " + table + " WHERE PAYDATE BETWEEN '"+startDate+"' and '"+endDate+"' and uuid[1,4] != 'YYLF' "  );
            }
            stmt.executeBatch();
            ConnectionUtil.commitTransaction(conn);
            stmt.close();

            stmt = conn.createStatement();
            // 方法订阅号
            String channel = "default";
            // 用于记录任务完成情况的map
            final Map<String,Integer> historyMap = new HashMap<>();
            for (String tableClass:
                 tableMap.values()) {
                Class cl = ClassUtils.getClass(tableClass);
                if(cl!=null){
                    historyMap.put(cl.getSimpleName(),0);
                }
            }
            // 防止 historyMap 多线程写入出现问题
            final ReadWriteLock lock = new ReentrantReadWriteLock();
            // 组建佣兵*
            MercenaryGroup mercenaryGroup
                    = new MercenaryGroup(new ReserveMissionHandler(),
                        100,
                        1,
                        new ReserveMissionListenner() {
                            public void handleAfter(Mission mission) {
                                List<Object> objects = (List<Object>) mission.getContent();
                                String simpleClassName = objects.get(0).getClass().getSimpleName();
                                try{
                                    lock.writeLock().lock();
                                    if(historyMap.containsKey(simpleClassName)){
                                        historyMap.put(simpleClassName,historyMap.get(simpleClassName)+objects.size());
                                    }else{
                                        historyMap.put(simpleClassName,objects.size());
                                    }
                                }catch (Exception e){
                                    throw e;
                                }finally {
                                    lock.writeLock().unlock();
                                }
                            }
                        });

            for (String table: tableMap.keySet()){
                // 循环表名生成任务向佣兵*指*
                ResultSet resultSet = stmt.executeQuery("SELECT * FROM SYN_REINS_"+table+" WHERE PAYDATE BETWEEN '"+startDate+"' and '"+endDate+"' ");
                List<Object> list = new ArrayList<>();
                int max = 50;
                while (resultSet!=null && resultSet.next()){
                    Class cl = ClassUtils.getClass(tableMap.get(table));
                    Object obj = JDBCUtils.turnResultSet(resultSet,cl);
                    if(list.size()<max-1){
                        list.add(obj);
                    }else{
                        list.add(obj);
                        Mission mission  = new Mission();
                        mission.setContent(list);
                        mercenaryGroup.execute(channel,mission);
                        list = new ArrayList<>();
                    }
                }
                if(list.size()!=0){
                    Mission mission  = new Mission();
                    mission.setContent(list);
                    mercenaryGroup.execute(channel,mission);
                }
                // 原逻辑
                //stmt.addBatch("INSERT INTO "+table+" SELECT * FROM SYN_REINS_"+table+" WHERE PAYDATE BETWEEN '"+startDate+"' and '"+endDate+"' ");
            }
            // 等待任务全部完成
            mercenaryGroup.waitForDead(60000);
            // 销毁佣兵*
            mercenaryGroup.destory();

            System.out.println("全部任务执行完毕：开始时间："+startDate+"；结束时间："+endDate+"；startDate"+historyMap.toString());
            stmt.close();

            stmt = conn.createStatement();
            for(String tableName:historyMap.keySet()){
                String sql = "UPDATE ZRJREINSSTATUS SET STATUS='2',ZRJCOUNT="+historyMap.get(tableName)+" WHERE STARTDATE='"+startDate+"' AND ENDDATE='"+endDate+"' AND TABLENAME='"+tableName.toLowerCase()+"' ";
                stmt.addBatch(sql);
            }
            //更新update
            stmt.executeBatch();
            stmt.close();
            status = "SUCCESS";
            //执行完毕后通知再保系统
            ConnectionUtil.commitTransaction(conn);
        }catch (Exception e){
            e.printStackTrace();
            ConnectionUtil.rollBackTransaction(conn);
            status=e.getMessage();
        }finally{
            requestString = XMLUtils.createRequestXML(XstreamUtils.getRequestHeaderXstream(),startDate,endDate,status);
            String responseString = "";
            try {
                responseString = HttpClientUtils.httpPostSend(interfaceAddress.getString("reinsinterface"),requestString);
            } catch (Exception e1) {
                e1.printStackTrace();
            }finally{
                if(backdoorFlag){
                    return;
                }
                //生成并发送报文日志记录
                RequestHead requestHead = HttpHeadUtils.getRequestHead();
                KeyInfo keyInfo = new KeyInfo();
                keyInfo.setBusstartdate(startDate);
                String UUID = requestString.substring(requestString.indexOf("<uuid>")+6, requestString.lastIndexOf("</uuid>"));
                String sender = requestString.substring(requestString.indexOf("<sender>")+8, requestString.lastIndexOf("</sender>"));
//                          String password = requestString.substring(requestString.indexOf("<password>")+10, requestString.lastIndexOf("</password>"));
                String requestType = requestString.substring(requestString.indexOf("<request_type>")+14, requestString.lastIndexOf("</request_type>"));
                requestHead.setUuid(UUID);
//                          requestHead.setPassword(password);
                requestHead.setRequest_type(requestType);
                requestHead.setSender(sender);
                //传送开始时间
                Date date = new Date();
                try {
                    interfaceLogService.addNewLog(requestString,responseString,requestHead,keyInfo,date);
                }catch (Exception e){
                    log.error("准备金发送业务系统报文保存失败",e);
                }

            }
            System.out.println("--0--"+ requestString);
            ConnectionUtil.closeConnect(conn);
            ConnectionUtil.closeStatements(stmt);
        }
    }

}

调用同步异步方法：

@RequestMapping(value="ReinsServlet_backdoor",produces="application/json;charset=UTF-8")
    @ResponseBody
    public void backdoor(
            @RequestParam("startDate") String startDate,
            @RequestParam("endDate") String endDate){
        if(startDate == null || endDate == null){
            return;
        }
        //调用异步同步方法
        Thread t = new SynoInterfaceData(
                interfaceLogService,
                dataDictionaryService,
                startDate,endDate,true);
        t.start();
    }