ConcurrentLatch

<dependency>
    <groupId>org.zxp</groupId>
    <artifactId>concurrentLatch</artifactId>
    <version>1.2-SNAPSHOT</version>
</dependency>

public class RuleLatch implements  LatchThread {
    RuleDto dto = null;
    /**通过构造方法传递入参*/
    public RuleLatch(RuleDto args){
        dto = args;
    }
    /**你的业务处理*/
    public RuleDto handle() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        dto.setMmmm(dto.getMmmm()+ 9999);
        return dto;
    }
}

/**添加这个类运行的任务名，注意这个名字在一次线程池运行中不可重复*/
/**也可以不配置注解，写一个名为TASKNAME的字符串成员变量也可行*/
@LatchTaskName("rule")
public class RuleLatch implements  LatchThread {
    RuleDto dto = null;
    /**通过构造方法传递入参*/
    public RuleLatch(RuleDto args){
        dto = args;
    }
    /**你的业务处理*/
    public RuleDto handle() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        dto.setMmmm(dto.getMmmm()+ 9999);
        return dto;
    }
}
/**添加这个类运行的任务名，注意这个名字在一次线程池运行中不可重复*/
/**也可以不配置注解，写一个名为TASKNAME的字符串成员变量也可行*/
/**返回对象配置的注解值必须和对应的LatchThread实现类一致，否则无法获取返回值对应关系*/
@LatchTaskName("rule")
public class RuleDto {
……
}

/**创建一个ConcurrentLatch执行器*/
ConcurrentLatch excutor = ConcurrentLatchExcutorFactory.getConcurrentLatch();
/**也可以通过其他静态方法获取其他的ConcurrentLatch*/
//ConcurrentLatch excutorproxy = ConcurrentLatchExcutorFactory.getConcurrentLatch(ConcurrentLatchExcutorFactory.ExcutorType.PROXY);
/**组织需要并发的业(任)务(务)类对象*/
LatchThread platformLatchThread = new PlatformLatch();//业务类A
RuleDto ruleDto = new RuleDto();
ruleDto.setRuleID("zxp123");
ruleDto.setMmmm(0.00001);
LatchThread ruleLatchThread = new RuleLatch(ruleDto);//业务类B
/**将任务推入ConcurrentLatch执行器*/
excutor.put(platformLatchThread,"AAA");
excutor.put(ruleLatchThread,"BBB");
/**可以把一个之前已经有的业务组件再放入池中，只需要名称不重复即可，当然你可以可以重新new一个*/
excutor.put(platformLatchThread,"CCC");
/**通知ConcurrentLatch执行器开始执行所有推入的任务*/
/**这里主线程或调用线程会挂起，直到所有任务都执行完毕*/
Map<String, Object> map = excutor.excute();
/**获取返回值*/
/**这里的key就是上面在注解(LatchTaskName)或者TASKNAME配置的值，能轻松的获取所有的返回对象*/
for (String key : map.keySet()) {
    Object out = map.get(key);
}

/**创建一个ConcurrentLatch执行器，不同点*/
ConcurrentLatch excutor =
ConcurrentLatchExcutorFactory.getConcurrentLatch(ConcurrentLatchExcutorFactory.ExcutorType.NORMAL);
/**组织需要并发的业(任)务(务)类对象*/
LatchThread platformLatchThread = new PlatformLatch();//业务类A
RuleDto ruleDto = new RuleDto();
ruleDto.setRuleID("zxp123");
ruleDto.setMmmm(0.00001);
LatchThread ruleLatchThread = new RuleLatch(ruleDto);//业务类B
/**将任务推入ConcurrentLatch执行器，不同点是这里只有一个入参*/
excutor.put(platformLatchThread);
excutor.put(ruleLatchThread);
/**不可以把一个之前已经有的业务组件再放入池中，即使你重新new了一个实例也不允许，这也是为什么我们不推荐使用这种方式的原因*/
/**通知ConcurrentLatch执行器开始执行所有推入的任务*/
/**这里主线程或调用线程会挂起，直到所有任务都执行完毕*/
Map<String, Object> map = excutor.excute();
/**获取返回值*/
/**这里的key就是上面在注解(LatchTaskName)或者TASKNAME配置的值，能轻松的获取所有的返回对象*/
/**再一次强调，必须把handle方法返回的类配置与对应的LatchThread实现类一致的注解任务名称，否则无法正常获取对应关系*/
for (String key : map.keySet()) {
    Object out = map.get(key);
}

我是BBB
我是AAA
我是AAA
taskname==========aaa
PlatformDto{name='0516', premium=6500.98, policyNo='000000000001'}
taskname==========ccc
PlatformDto{name='0516', premium=6500.98, policyNo='000000000001'}
taskname==========bbb
RuleDto{ruleID='zxp123', mmmm=9999.00001}

LatchExcutorBlockingQueueManager.print();

/**
 * 单个线程池最大核心线程数
 */
public static final int MAX_CORE_POOL_SIZE = 10;

<!--详见org.zxp.ConcurrentLatch.LatchExcutorBlockingQueueManager#getExcutor-->
excutor = new ThreadPoolExecutor(corepoolsize, threadCount*Constants.MAX_POOL_SIZE_RATIO , 60, TimeUnit.SECONDS, queue);

/**
 * 最大线程池数量倍数
 */
public static final int MAX_POOL_SIZE_RATIO = 2;

/**
 * 是否有界，默认无界，即不会有任务超出容量导致丢弃任务的情况
 */
public static final boolean HAS_LIMITS = false;

/**
 * 任务等待队列长度，有界时有效
 */
public static final int LIMITS_SIZE = 50;

/**
 * 线程池最大数量
 */
public static final int MAX_EXCUTOR_SIZE= 20;

/**
 * 通过尝试后无法获得线程池资源，是否挂起等待（false抛出异常）
 */
public static final boolean AFTER_TRY_BLOCK = false;