併發模型（二）——Master-Worker模式

轉載：http://blog.csdn.net/lmdcszh/article/details/39698189

aster-Worker模式是常用的並行模式之一，它的核心思想是，系統有兩個進程協作工作：Master進程，負責接收和分配任務；Worker進程，負責處理子任務。當Worker進程將子任務處理完成後，結果返回給Master進程，由Master進程做歸納彙總，最後得到最終的結果。

一、什麼是Master-Worker模式：

該模式的結構圖：

  結構圖：

Worker：用於實際處理一個任務；

Master：任務的分配和最終結果的合成；

Main：啓動程序，調度開啓Master。

二、代碼實現：

    下面的是一個簡易的Master-Worker框架實現。

（1）Master部分：

package MasterWorker;

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

public class Master {

    //任務隊列
    protected Queue<Object> workQueue= new ConcurrentLinkedQueue<Object>();
    //Worker進程隊列
    protected Map<String ,Thread> threadMap= new HashMap<String ,Thread>();
    //子任務處理結果集
    protected Map<String ,Object> resultMap= new ConcurrentHashMap<String, Object>();
    //是否所有的子任務都結束了
    public boolean isComplete(){
        for(Map.Entry<String , Thread> entry:threadMap.entrySet()){
            if(entry.getValue().getState()!=Thread.State.TERMINATED){
                return false;
            }

        }
        return true ;
    }

    //Master的構造，需要一個Worker進程邏輯，和需要Worker進程數量
    public Master(Worker worker,int countWorker){

        worker.setWorkQueue(workQueue);
        worker.setResultMap(resultMap);
        for(int i=0;i<countWorker;i++){
            threadMap.put(Integer.toString(i),  new Thread(worker, Integer.toString(i)));
        }

    }

    //提交一個任務
    public void submit(Object job){
        workQueue.add(job);
    }


    //返回子任務結果集
    public Map<String ,Object> getResultMap(){
        return resultMap;
    }


    //開始運行所有的Worker進程，進行處理
    public  void execute(){
         for(Map.Entry<String , Thread> entry:threadMap.entrySet()){
             entry.getValue().start();

         }
    }


}

（2）Worker進程實現：

package MasterWorker;

import java.util.Map;
import java.util.Queue;

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;
    }
    //子任務處理的邏輯，在子類中實現具體邏輯
    public Object handle(Object input){
        return input;
    }


    @Override
    public void run() {

        while(true){
            //獲取子任務
            Object input= workQueue.poll();
            if(input==null){
                break;
            }
            //處理子任務
            Object re = handle(input);
            resultMap.put(Integer.toString(input.hashCode()), re);
        }
    }

}

（3）運用這個小框架計算1——100的立方和，PlusWorker的實現：

package MasterWorker;

public class PlusWorker extends Worker {

    @Override
    public Object handle(Object input) {

        Integer i =(Integer)input;
        return i*i*i;
    }


}

（4）進行計算的Main函數：

package MasterWorker;

import java.util.Map;
import java.util.Set;

public class Main {


    /**
     * @param args
     */
    public static void main(String[] args) {
        //固定使用5個Worker，並指定Worker
        Master m = new Master(new PlusWorker(), 5);
        //提交100個子任務
        for(int i=0;i<100;i++){
            m.submit(i);
        }
        //開始計算
        m.execute();
        int re= 0;
        //保存最終結算結果
        Map<String ,Object> resultMap =m.getResultMap();

        //不需要等待所有Worker都執行完成，即可開始計算最終結果
        while(resultMap.size()>0 || !m.isComplete()){
            Set<String> keys = resultMap.keySet();
            String key =null;
            for(String k:keys){
                key=k;
                break;
            }
            Integer i =null;
            if(key!=null){
                i=(Integer)resultMap.get(key);
            }
            if(i!=null){
                //最終結果
                re+=i;
            }
            if(key!=null){
                //移除已經被計算過的項
                resultMap.remove(key);
            }

        }


    }

}

三、總結：

    Master-Worker模式是一種將串行任務並行化的方案，被分解的子任務在系統中可以被並行處理，同時，如果有需要，Master進程不需要等待所有子任務都完成計算，就可以根據已有的部分結果集計算最終結果集。