Master-Worker实现计算1-100的平方和

Task类：

package com.thread.masterworker;
public class Task {
private int id;
private String name;
private int num;

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 getNum() {
    return num;
}

public void setNum(int num) {
    this.num = num;
}

}
Master实现：

package com.thread.masterworker;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;

public class Master {
//所有任务的队列
private ConcurrentLinkedQueue workerQueue = new ConcurrentLinkedQueue();

//所有worker
private HashMap<String,Thread> workers = new HashMap<String,Thread>();

//共享变量，worker返回的结果
private ConcurrentHashMap<String,Object> resultMap = new ConcurrentHashMap<String,Object>();

//构造方法,初始化所有worker
public Master(Worker worker,int workerCount){
    worker.setWorkerQueue(this.workerQueue);
    worker.setResultMap(this.resultMap);

    for (int i = 0; i < workerCount; i++) {
        Thread t = new Thread(worker);
        this.workers.put("worker-"+i,t);
    }
}

//任务的提交
public void submit(Task task){
    this.workerQueue.add(task);
}

//执行任务
public int execute(){
    for (Map.Entry<String, Thread> entry : workers.entrySet()) {
        entry.getValue().start();
    }

    //一直循环，直到结果返回
    while (true){
        if(isComplete()){
            return getResult();
        }
    }

}

//判断是否所有线程都已经执行完毕
public boolean isComplete(){
    for (Map.Entry<String, Thread> entry : workers.entrySet()) {
        //只要有任意一个线程没有结束，就返回false
        if(entry.getValue().getState() != Thread.State.TERMINATED){
            return false;
        }
    }
    return true;
}

//处理结果集返回最终结果
public int getResult(){
    int res = 0;
    for (Map.Entry<String,Object> entry : resultMap.entrySet()) {
        res += (Integer) entry.getValue();
    }
    return res;
}

}
父类Worker：

package com.thread.masterworker;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;

public class Worker implements Runnable {

private ConcurrentLinkedQueue<Task> workerQueue;

private ConcurrentHashMap<String,Object> resultMap;

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 task = workerQueue.poll();
        if(task == null) break;
        //处理具体的任务
        Object res = doTask(task);
        //把每次处理的结果放到结果集里面，此处直接把num值作为结果
        resultMap.put(String.valueOf(task.getId()),res);
    }

}

public Object doTask(Task task) {
    return null;
}

}
子类MyWorker继承父类Worker，重写doTask方法实现具体的逻辑：

package com.thread.masterworker;

public class MyWorker extends Worker {
@Override
public Object doTask(Task task) {
//暂停0.5秒，模拟任务处理
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
//计算数字的平方
int num = task.getNum();
return num * num;
}
}
客户端Client：

package com.thread.masterworker;

import java.util.Random;

public class Client {
public static void main(String[] args) {

    Master master = new Master(new MyWorker(), 10);

    //提交n个任务到任务队列里
    for (int i = 0; i < 100; i++) {
        Task task = new Task();
        task.setId(i);
        task.setName("任务"+i);
        task.setNum(i+1);
        master.submit(task);
    }

    //执行任务
    long start = System.currentTimeMillis();
    int res = master.execute();
    long time = System.currentTimeMillis() - start;
    System.out.println("结果:"+res+",耗时:"+time);
}

}
龙华大道1号http://www.kinghill.cn/LongHuaDaDao1Hao/index.html