Java并行程式設計模式——Master-Worker模式

Master-Worker模式是常用并行模式之一，他的核心思想是==系統由兩類程序協作工作：Master程序和Worker程序。Master程序負責接收和配置設定任務，Worker程序負責處理子任務。==當各個Worker程序将子任務處理完成後，将結果集傳回給Master程序，由Master程序做歸納和彙總，進而得到系統的最終結果

好處

能夠将一個大任務分解成若幹個小任務，并行執行，進而提高系統的吞吐量。而對于系統請求者Client來說，任務一旦送出，Master程序會配置設定任務并立即傳回，并不會等待系統全部處理完成後再傳回，其處理方式是異步的，是以Client不會出現等待現象

Master-Worker模式結構

角色	作用
Worker	用于實際處理一個任務（處理邏輯在子類中實作）
Master	用于任務的配置設定和最終結果的合成
Main	啟動系統，排程開啟Master

注：Master-Worker模式是一種使用多線程進行資料處理的結構。多個Worker程序協作處理使用者請求，Master程序負責維護Worker程序，并整合最終處理結果

使用Master-Worker模式計算1到100的立方和

// Master程序為主要程序，維護了一個Worker程序隊列、子任務隊列和子結果集
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 obj) {
        workQueue.add(obj);
    }

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

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

// Worker程序隊列中的Worker程序，不停地從任務隊列提取要處理的子任務，并将子任務的處理結果寫入結果集
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);
        }
    }
}
           

// Worker的子類，實作了處理邏輯
public class PulsWorker extends Worker {
    @Override
    public Object handle(Object input) {
        Integer i = (Integer) input;
        return i * i * i;
    }
}
           

public class Main {
    public static void main(String[] args) {
        Master m = new Master(new PulsWorker(), 5);
        for (int i = 1; i <= 100; i++) {
            m.submit(i);
        }
        m.execute();
        int re = 0;
        Map<String, Object> resultMap = m.getResultMap();
        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);
            }
        }
        System.out.println(re);
    }
}
           

// 運作結果
25502500
           

分析

• 計算任務被分解為100個子任務，每個子任務僅用于計算單獨的立方和
• Master産生固定個數（該程式中為5個）的Worker來處理這些子任務
• Master送出子任務
• 5個Worker同時不斷從任務集合中擷取計算立方和的子任務，并将計算結果傳回給Master
• Master将Worker每次傳回的結果進行累加，當5個活躍的Worker程序全部終止，才會給出最終計算結果

  

注：整個計算過程中，Master和Work的運作是完全異步的，Master不必等到所有Worker都執行完畢後，就可以進行就和操作，即Master在獲得部分子任務結果集時，就已經可以開始對最終結果進行計算，進而進一步提高系統的并行度和吞吐量