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

一、什麼是Master-Worker模式：

該模式的結構圖：

  結構圖：

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

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

Main：啟動程式，排程開啟Master。

二、程式碼實現：

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

（1）Master部分：

[java]  view plain  copy  

1. package MasterWorker;  
2.   
3. import java.util.HashMap;  
4. import
    java.util.Map;  
5. import java.util.Queue;  
6. import java.util.concurrent.ConcurrentHashMap;  
7. import java.util.concurrent.ConcurrentLinkedQueue;  
8.   
9. public class Master {  
10.   
11.     //任務佇列  
12.     protected Queue<Object> workQueue= new ConcurrentLinkedQueue<Object>();  
13.     //Worker程序佇列  
14.     protected Map<String ,Thread> threadMap= new HashMap<String ,Thread>();  
15.     //子任務處理結果集  
16.     protected Map<String ,Object> resultMap= new ConcurrentHashMap<String, Object>();  
17.     //是否所有的子任務都結束了  
18.     public boolean isComplete(){  
19.         for(Map.Entry<String , Thread> entry:threadMap.entrySet()){  
20.             if(entry.getValue().getState()!=Thread.State.TERMINATED){  
21.                 return false;  
22.             }  
23.                   
24.         }  
25.         return true ;  
26.     }  
27.       
28.     //Master的構造，需要一個Worker程序邏輯，和需要Worker程序數量  
29.     public Master(Worker worker,int countWorker){  
30.           
31.         worker.setWorkQueue(workQueue);  
32.         worker.setResultMap(resultMap);  
33.         for(int i=0;i<countWorker;i++){  
34.             threadMap.put(Integer.toString(i),  new Thread(worker, Integer.toString(i)));  
35.         }  
36.           
37.     }  
38.       
39.     //提交一個任務  
40.     public void submit(Object job){  
41.         workQueue.add(job);  
42.     }  
43.       
44.       
45.     //返回子任務結果集  
46.     public Map<String ,Object> getResultMap(){  
47.         return resultMap;  
48.     }  
49.       
50.       
51.     //開始執行所有的Worker程序，進行處理  
52.     public  void execute(){  
53.          for(Map.Entry<String , Thread> entry:threadMap.entrySet()){  
54.              entry.getValue().start();  
55.                
56.          }  
57.     }  
58.       
59.       
60. }  

（2）Worker程序實現：

[java]  view plain  copy  

1. package MasterWorker;  
2.   
3. import java.util.Map;  
4. import java.util.Queue;  
5.   
6. public class Worker  implements Runnable{  
7.   
8.     //任務佇列，用於取得子任務  
9.     protected Queue<Object> workQueue;  
10.     //子任務處理結果集  
11.     protected Map<String ,Object> resultMap;  
12.     public void setWorkQueue(Queue<Object> workQueue){  
13.         this.workQueue= workQueue;  
14.     }  
15.       
16.     public void setResultMap(Map<String ,Object> resultMap){  
17.         this.resultMap=resultMap;  
18.     }  
19.     //子任務處理的邏輯，在子類中實現具體邏輯  
20.     public Object handle(Object input){  
21.         return input;  
22.     }  
23.       
24.       
25.     @Override  
26.     public void run() {  
27.           
28.         while(true){  
29.             //獲取子任務  
30.             Object input= workQueue.poll();  
31.             if(input==null){  
32.                 break;  
33.             }  
34.             //處理子任務  
35.             Object re = handle(input);  
36.             resultMap.put(Integer.toString(input.hashCode()), re);  
37.         }  
38.     }  
39.   
40. }  

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

[java]  view plain  copy  

1. package MasterWorker;  
2.   
3. public class PlusWorker extends Worker {  
4.   
5.     @Override  
6.     public Object handle(Object input) {  
7.           
8.         Integer i =(Integer)input;  
9.         return i*i*i;  
10.     }  
11.   
12.       
13. }  

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

[java]  view plain  copy  

1. package MasterWorker;  
2.   
3. import java.util.Map;  
4. import java.util.Set;  
5.   
6. public class Main {  
7.   
8.       
9.     /** 
10.      * @param args 
11.      */  
12.     public static void main(String[] args) {  
13.         //固定使用5個Worker，並指定Worker  
14.         Master m = new Master(new PlusWorker(), 5);  
15.         //提交100個子任務  
16.         for(int i=0;i<100;i++){  
17.             m.submit(i);  
18.         }  
19.         //開始計算  
20.         m.execute();  
21.         int re= 0;  
22.         //儲存最終結算結果  
23.         Map<String ,Object> resultMap =m.getResultMap();  
24.           
25.         //不需要等待所有Worker都執行完成，即可開始計算最終結果  
26.         while(resultMap.size()>0 || !m.isComplete()){  
27.             Set<String> keys = resultMap.keySet();  
28.             String key =null;  
29.             for(String k:keys){  
30.                 key=k;  
31.                 break;  
32.             }  
33. 相關推薦

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

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

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

    string 程序 分配任務 之一 size void con .exe || Master-Worker模式是常用的並行模式之一，它的核心思想是，系統有兩個進程協作工作：Master進程，負責接收和分配任務；Worker進程，負責處理子任務。當Worker進程將子任

    Java Thread系列（九）Master-Worker模式

    線程 支持 需要 列表 deque 開啟 exc oid src Java Thread系列（九）Master-Worker模式 Master-Worker模式是常用的並行設計模式. 一、Master-Worker 模式核心思想 Master-Worker 系統由兩個角

    IO通訊模型（二）同步非阻塞模式NIO（NonBlocking IO）

    同步非阻塞模式（NonBlocking IO） 在非阻塞模式中，發出Socket的accept()和read()操作時，如果核心中的資料還沒有準備好，那麼它並不會阻塞使用者程序，而是立刻返回一個資訊。也就是說程序發起一個read操作後，並不需要一直阻塞等待，而是馬上就得到了一個結果。 如果結果發現數據準備

    Akka併發程式設計——第三節：Actor模型（二）

    本節主要內容： Actor API解析 1. Actor API解析 Actor中的主要成員變數和方法定義如下： package akka.actor trait Actor extends scala.AnyRef { type Rec

    從單例模式挖到記憶體模型（二）----指令重排序

    首先是一個雙檢鎖寫的單例模式的例子： public class Single{ private volatile static Single single; private Single(){} public static Single getInstance(){

    Spark原始碼學習（二）---Master和Worker的啟動以及Actor通訊流程

    在《Spark原始碼學習（一）》中通過Spark的啟動指令碼，我們看到Spark啟動Master的時候實際上是啟動了org.apache.spark.deploy.master.Master，下面我們就從這2個類入手，通過閱讀Spark的原始碼，瞭解Spark的啟動流程。

    Java內存模型（二）——重排序

    序列 依賴性 種類 如果 禁止 加載 runtime 屬於 style 一、重排序 　　重排序是指為了提高程序的執行效率，編譯器和處理器常常會對語句的執行順序或者指令的執行順序進行重排。 編譯器優化的重排序:編譯器在不改變單線程程序語義的前提下，可以重新安排語句的執行順序

    設計模式（二）： 工廠模式

    dem blank hibernate 執行 oid code 做出 void actor 工廠模式 工廠模式（Factory Pattern）是 Java 中最常用的設計模式之一。這種類型的設計模式屬於創建型模式，它提供了一種創建對象的最佳方式。 在工廠模式中，我們在創建

    NLP —— 圖模型（二）條件隨機場（Conditional random field，CRF）

    而在 mar 依賴 alt strong $$ href 否則 block 本文簡單整理了以下內容： （一）馬爾可夫隨機場（Markov random field，無向圖模型）簡單回顧 （二）條件隨機場（Conditional rand

    設計模式（二）---工廠方法模式

    ack cto sys alt 修改 spa 抽象類 .com desc 1、簡介：工廠方法模式是類的創建模式，又叫虛擬構造子模式或是多態性工廠模式，它的實現方式是創建一個工廠接口，將實際創建對象的的工作轉移到工廠子類中，在系統的擴展中，可以在不修改工廠角色的情況下引進新的

    設計模式（二）——工廠方法模式

    設計模式學習（二）“觀察者模式” （C#）

    original pan 學習筆記 pri 接口 program date contain 兩個 《深入淺出設計模式》學習筆記第二章 需求： 開發一套氣象監測應用，如圖： 氣象站，目前有三種裝置，溫度、濕度和氣壓感應裝置。 WeatherData對象追蹤氣象站的數據，並更

    Django中模型（二）

    for 唯一值 校驗 允許 小數 如果 git ade 字符長度 Django中模型（二） 三、定義模型 1、模型、屬性、表、字段間的關系： 一個模型類在數據庫中對應一張表；在模型類中定義的屬性，對應該模型對照表中的字段。 2、定義屬性 A、概述

    設計模式學習筆記（二）--簡單工廠模式和工廠模式

    bsp bubuko rac oid nds gen body () pri 老生長談的兩個設計模式了，這裏把這兩個設計模式對比著來總結一下。 什麽是簡單工廠模式？ 簡單工廠模式：根據傳入工廠類的參數動態決定要創建哪一個產品類的實例。 UML圖如下（以實現一個計算器為例）：

    Linux學習筆記（十八） vim（二）、編輯模式、vim實踐練習

    編輯模式 命令模式 vim實踐 一、 編輯模式 命令行模式替換時如果需要替換的字符中有/符號，那麽可以將分隔符換成#或者@ ：1,100s#/good/weer/#well#g 將前一百行中的/good/weer/替換為well，：nohl 取消搜索時的高亮顯示，：x也是保存並退出，但是如果並

    java內存模型（二）深入理解java內存模型的系列好文

    總結 nal href ola down 深入理解 ati markdown vol 深入理解java內存模型（一）——基礎深入理解java內存模型（二）——重排序深入理解java內存模型（三）——順序一致性深入理解java內存模型（四）——volatile深入理解java

    23種設計模式介紹（二）---- 結構型模式

    implement weight 代碼 介紹 定義 裝飾器模式 大量 技術分享 記憶 由於設計模式篇幅比較大，如果在一篇文章講完所有的設計模式的話不利於閱讀。於是我把它分為三篇文章 23種設計模式介紹（一）---- 創建型模式 23種設計模式介紹（二）---- 結構

    分層網絡模型（二）

    就是 發送數據 求根 assigned BE ber main 另一個 google 　　傳輸層，將數據以包的方式進行發送並且保存，直到收到確認後才將保存的數據丟棄，否則再次將保存的數據進行發送，即提供數據傳輸的服務。TCP協議就是提供可靠的數據傳輸。　　網際互聯層關心的是

    常用的JavaScript設計模式（二）Factory(工廠)模式

    asc 我們 對象實例 actor 通過 汽車 對象 UNC cti Factory通過提供一個通用的接口來創建對象，同時，我們還可以指定我們想要創建的對象實例的類型。 假設現在有一個汽車工廠VehicleFactory，支持創建Car和Truck類型的對象實例，現在需要通