本文作为，其他文章链接使用，单独参考意义不大。
Master-Worker框架如下，首先实现的Master线程，主要用作分配任务，和返回结果集。
/**
* Created by Joker on 2015/3/9.
*/
public class Master {
//任务队列
protected Queue<Object> workQueue = new ConcurrentLinkedQueue<Object>();
//线程队列
protected Map<String, Thread> threadMap = new HashMap<String, Thread>();
//子任务处理结果集
protected Map<String, Object> resultMap = new ConcurrentHashMap<String, Object>();
public Master(Worker worker, int workerCount) {
worker.setWorkQueue(workQueue);
worker.setResultMap(resultMap);
if (workerCount > 5)
workerCount = 5;
/*根据workerCount，创建指定数量的工作线程Worker*/
for (int i = 0; i < workerCount; i++) {
threadMap.put(Integer.toString(i), new Thread(worker, Integer.toString(i)));
}
}
/**
* 检查子任务是否全部执行完毕
*/
public boolean isComplete() {
for (Map.Entry<String, Thread> entry : threadMap.entrySet()) {
if (entry.getValue().getState() != Thread.State.TERMINATED) {
return false;
}
}
return true;
}
/**
* 提交任务
*/
public void submit(Object object) {
workQueue.add(object);
}
/**
* 获取子任务结果集
*
* @return 结果集
*/
public Map<String, Object> getResultMap() {
return resultMap;
}
/**
* 执行所有工作线程worker，处理任务。
*/
public void execute() {
for (Map.Entry<String, Thread> entry : threadMap.entrySet()) {
entry.getValue().start();
}
}
}
Worker作为子线程，实现在Handle方法中实现具体业务逻辑，并加处理结果放到结果集中。
/**
* Created by Joker on 2015/3/9.
*/
public class Worker implements Runnable {
//子任务队列，用于过去子任务
protected Queue<Object> workQueue;
//结果集
protected Map<String, Object> resultMap;
public void setWorkQueue(Queue<Object> workQueue) {
this.workQueue = workQueue;
}
public void setResultMap(Map<String, Object> resultMap) {
this.resultMap = resultMap;
}
/**
* 执行具体业务逻辑
* 模拟立方和计算
*
* @param object
* @return
*/
public Object handle(Object object) {
Integer i = (Integer) object;
return i * i * i;
}
@Override
public void run() {
while (true) {
//获取任务
Object work = workQueue.poll();
if (work == null)
break;
resultMap.put(Integer.toString(work.hashCode()), this.handle(work));
}
}
}
需要调用的地方，进行立方和计算。
/**
* 计算立方和1~100的立方和
*/
public void executeCubic() {
//创建三个Worker线程，执行任务
Master master = new Master(new Worker(), 3);
for (int i = 0; i < 100; i++) {
master.submit(i);
}
//执行任务
master.execute();
//计算结果，初始化
int result = 0;
//计算结果集
Map<String, Object> resultMap = master.getResultMap();
while (resultMap.size() > 0 || !master.isComplete()) {
String key = null;
Integer i = null;
for (String k : resultMap.keySet()) {
key = k;
break;
}
if (key != null) {
i = (Integer) resultMap.get(key);
//从结果集中移除倍计算过的key
resultMap.remove(key);
}
if (i != null) {
result += i;
}
}
}
提交100个任务后由3个Worker线程进行计算，Master并不等待所有Worker线程执行完毕，就开始访问子结果集，进行相加计算，直到子结果集中的所有数据处理完毕，并且3个活跃Worker线程全部停止，才给出最终的立方总和。result最终结果便是1~100立方和。
