项目上碰到一个java后台实现问题，底层依赖的以前开发团队的rabbitMQ的实现，该底层open了一个channel，并一直保持着对该channel的监听，在这个基础上我需要实现的就是一直监听该channel，并将接受到的消息交给其他线程去处理，保证监听主线程不被阻塞。需求大致是这样的。
下面看下我的具体实现：
一、主线程监听消息队列，并将接受的消息交给其他线程去处理，并且处理消息的其他线程数量有限制。这里考虑用concurrent包里的semaphore，信号量可以认为是一定数量num的许可证，主线程将消息和一张许可证交给一个子线程去处理，子线程处理完了（不管成功或失败）都要将许可证上交给主线程，供下一个子线程使用，这样就可能出现两种情况：1）许可证富裕，主线程继续将消息交给子线程去消费；2）许可证已被多个子线程占用，还未交回主线程手里。这样主线程就阻塞了。这个玩意刚好满足我的业务需求。看下代码：
private int threadNum = 10;
private Semaphore semaphore = new Semaphore(threadNum);
private Executor executor = Executors.newCachedThreadPool();
private int allowedChildThreads = 10;
public void doJob() {
Logger.info("begin consuming!", new Object[0]);
MessageClientFactory.getClient().consume("xxxQueue", true, new MessageConsumer() {
@Override
public void consume(String message) {
Logger.info(message, new Object[0]);
try {
JSONObject messageObject = JSONObject.parseObject(message);
String jobType = messageObject.getString("job_type"); //任务类型
String jobID = messageObject.getString("job_id"); //任务ID
Date jobSubmitTime = messageObject.getDate("job_submit_time"); //任务提交时间
String params = messageObject.getString("params"); //任务指标参数
//构建线程间信息传递对象
Map<String, String> threadDelivery = new HashMap<>();
threadDelivery.put("job_type", jobType);
threadDelivery.put("job_id", jobID);
threadDelivery.put("params", params);
semaphore.acquire(); //许可证减少一张
executor.execute(new MessageSplitToMany(threadDelivery, semaphore, executor, allowedChildThreads)); //将消费信息和许可证一并交给子线程MessageSplitToMany，他处理完释放许可证
} catch (Exception e) {
Logger.error(e, "消费主线程发生错误", new Object[0]);
}
}
});
}二、MessageSplitToMany子线程进一步将消息拆分并交给一定数量的孙线程处理（用semaphore限制并发数），在这些孙线程未全部处理完成前，MessageSplitToMany子线程阻塞。这里CountDownLatch正好满足需求。
/**
* 一条消息分解成多个指标线程并行计算
* @author fujian
*
*/
public class MessageSplitToMany implements Runnable {
private Map<String, String> threadDelivery;
private Semaphore semaphore;
private Executor executor;
private int allowedChildThreads;
public MessageSplitToMany(Map<String, String> threadDelivery, Semaphore semaphore, Executor executor, int allowedChildThreads) {
this.threadDelivery = threadDelivery;
this.semaphore = semaphore;
this.executor = executor;
this.allowedChildThreads = allowedChildThreads;
}
@Override
public void run() {
try {
String params = threadDelivery.get("params");
Logger.info(params, new Object[0]);
JSONObject multiIdxParams = JSONObject.parseObject(params);
//对并发处理单个指标计算的工作线程数量有一定的约束,所允许的工作线程数量不能超过设定值
if(allowedChildThreads > multiIdxParams.size()) {
allowedChildThreads = multiIdxParams.size();
}
Semaphore innerSemaphore = new Semaphore(allowedChildThreads);
CountDownLatch countDownLatch = new CountDownLatch(multiIdxParams.size());
for(String idxName : multiIdxParams.keySet()) {
String idxParams = multiIdxParams.getString(idxName);
Map<String, Object> childThreadDelivery = new LinkedHashMap<>();
childThreadDelivery.put("job_id", threadDelivery.get("job_id"));
childThreadDelivery.put("index_id", DigestUtils.md5Hex(idxName + idxParams));
childThreadDelivery.put("job_type", threadDelivery.get("job_type"));
childThreadDelivery.put("idx_name", idxName);
childThreadDelivery.put("params", idxParams);
innerSemaphore.acquire(); //孙信号量控制子线程中的并发数
executor.execute(new IdxCalAndSaveThread(countDownLatch, innerSemaphore, childThreadDelivery));//将countDownLatch及孙信号量传给IdxCalAndSaveThread孙线程，由它countdown及释放孙信号量
}
countDownLatch.await(); //在message中所有指标计算完成前主线程阻塞，直至countdown减为0
Logger.info("-----" + Thread.currentThread().getName() + "consumer thread finished the all idxCals Cal-----");
} catch (Exception e) {
Logger.error(e, "并发处理消息过程发生错误", new Object[0]);
} finally {
semaphore.release(); //释放子信号量，这个信号量是从主线程传递进来的
}
}
}
三、孙线程是最底层的处理线程，其最终要释放孙信号量及对countDownLatch减一，
/**
* 指标计算及存储
* @author fujian
*
*/
public class IdxCalAndSaveThread implements Runnable {
private Semaphore innerSemaphore;
private CountDownLatch countDownLatch;
private Map<String, Object> threadDelivery;
public IdxCalAndSaveThread(CountDownLatch countDownLatch, Semaphore innerSemaphore, Map<String, Object> threadDelivery) {
this.countDownLatch = countDownLatch;
this.innerSemaphore = innerSemaphore;
this.threadDelivery = threadDelivery;
}
@Override
public void run() {
try {
String idxName = threadDelivery.get("idx_name").toString();
String params = threadDelivery.get("params").toString();
threadDelivery.remove("params");
threadDelivery.put("start_time", System.currentTimeMillis());
//调用indexCal 层指标计算api，计算指标
//考虑idxName为idxCal_01
Object idx;
if(idxName.contains("_")) {
String idxCalName = idxName.substring(0, idxName.lastIndexOf("_"));
idx = IdxCalHandler.handle(idxCalName, params);
} else {
idx = IdxCalHandler.handle(idxName, params);
}
threadDelivery.put("end_time", System.currentTimeMillis());
threadDelivery.put("idx_result", idx);
Logger.info(idxName + "cal is finished!", new Object[0]);
//save to mongo
saveToDB(threadDelivery);
Logger.info(idxName + "cal result had saved into mongo", new Object[0]);
} catch (Exception e) {
Logger.error(e, "单个指标计算过程发生错误", new Object[0]);
} finally { //最终要释放孙信号量及countdown减一
innerSemaphore.release();
countDownLatch.countDown();
}
}
}