Master-Worker模式是常用的并行计算模式。它的核心思想是系统由两类线程协同工作:Master和Worker线程。Master进程负责接收和分配任务,Worker进程负责处理子任务。当各个Worker进程将子任务处理完后,将结果返回给Master进程,由Master进行归纳和汇总,从而得到系统结果。
Master-Worker模式的好处是,它能将大任务分解成若干个小任务,并发执行,从而提高系统性能。而对于系统请求者Client来说,任务一旦提交,Master进程就会立刻分配任务并立即返回,并不会等系统处理完全部任务再返回,其处理过程是异步的。
Task.java
package Work_Master;
/**
* Created by 胖大星 on 2017/9/13.
*/
public class Task {
private int id;
private String name;
private int prices;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrices() {
return prices;
}
public void setPrices(int prices) {
this.prices = prices;
}
}
Master.java
package Work_Master;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
/**
* Created by 胖大星 on 2017/9/13.
*/
public class Master {
//1.应该有一个承装任务的集合
private ConcurrentLinkedQueue<Task> workQueue = new ConcurrentLinkedQueue<Task>();
//2.使用HashMap去承装所有的work对象
private HashMap<String,Thread> workers = new HashMap<String,Thread>();
//3.使用一个容器承装每一个work并非执行任务的结果集
private ConcurrentHashMap<String,Object> resultMap = new ConcurrentHashMap<String,Object>();
//4.构造方法
public Master(Worker work, int workerCount){
//每一个worker对象都需要有Master的引用workQueue用于任务的领取,resultMap用于任务的提交
work.setWorkerQueue(this.workQueue);
work.setResultMap(this.resultMap);
for (int i = 0; i < workerCount; i++) {
//key表示每一个worker的名字,value表示线程执行对象
workers.put("子节点: " + Integer.toString(i), new Thread(work));
}
}
//5.提交方法
public void submit(Task task){
this.workQueue.add(task);
}
//6.需要一个执行的方法(启动应用程序让所有的worker工作)
public void execute(){
for (Map.Entry<String, Thread> me: workers.entrySet()){
me.getValue().start();
}
}
//判断线程是否执行完毕
public boolean isComplete(){
for (Map.Entry<String,Thread> me : workers.entrySet() ) {
if (me.getValue().getState() != Thread.State.TERMINATED)
return false;
}
return true;
}
//返回结果集数据
public int getResult(){
int ret = 0;
for (Map.Entry<String, Object> me : resultMap.entrySet()) {
//汇总的逻辑。。。
ret += (Integer)me.getValue();
}
return ret;
}
}
Worker.java
package Work_Master;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
/**
* Created by 胖大星 on 2017/9/13.
*/
//每个worker必须要实现Runnable接口
public class Worker implements Runnable{
//每一个worker对象都需要master的ConcurrentHashMap的引用
private ConcurrentHashMap<String,Object> resultMap;
//每一个worker对象都需要master的ConcurrentLinkedQueue的引用
private ConcurrentLinkedQueue<Task> workerQueue;
public void setWorkerQueue(ConcurrentLinkedQueue<Task> workerQueue) {
this.workerQueue = workerQueue;
}
public void setResultMap(ConcurrentHashMap<String,Object> resultMap) {
this.resultMap = resultMap;
}
@Override
public void run() {
while (true){
Task input = this.workerQueue.poll();
if (input == null) break;
//真正去做业务处理 可以利用MyWorker在此执行多个业务
Object output = MyWorker.handle(input);
this.resultMap.put(Integer.toString(input.getId()),output);
}
}
//用于子类继承,增强解耦
public static Object handle(Task input) {
return null;
}
}
MyWorker.java
package Work_Master;
/**
* Created by 胖大星 on 2017/9/13.
*/
public class MyWorker extends Worker {
//核心部分
public static Object handle(Task input) {
Object output = null;
try {
//表示处理task任务耗时,可能是数据的加工,也可能是操作数据库
Thread.sleep(500);
output = input.getPrices();
} catch (InterruptedException e) {
e.printStackTrace();
}
return output;
}
}
Main.java
package Work_Master;
import java.util.Random;
/**
* Created by 胖大星 on 2017/9/13.
*/
public class Main {
public static void main(String[] args) {
//Runtime.getRuntime().availableProcessors() 可自定义执行线程数
Master master = new Master(new MyWorker(),Runtime.getRuntime().availableProcessors());
System.out.println("当前计算机可用线程数量:"+Runtime.getRuntime().availableProcessors());
Random random = new Random();
for (int i = 0; i < 100; i++) {
Task t = new Task();
t.setId(i);
t.setName("task: " + i);
t.setPrices(random.nextInt(1000));
master.submit(t);
}
master.execute();
long start = System.currentTimeMillis();
while (true){
if (master.isComplete())
{
long end = System.currentTimeMillis() - start;
int ret = master.getResult();
System.out.println("最终结果为: " +ret + ", 执行耗时: "+end);
break;
}
}
}
}