转 Master-Worker模式并行程序设计模式--Master-Worker模式

简介

　　Master-Worker模式是常用的并行设计模式。它的核心思想是，系统有两个进程协议工作：Master进程和Worker进程。Master进程负责接收和分配任务，Worker进程负责处理子任务。当各个Worker进程将子任务处理完后，将结果返回给Master进程，由Master进行归纳和汇总，从而得到系统结果。处理过程如下图：

Master-Worker模式的好处是，它能将大任务分解成若干个小任务，并发执行，从而提高系统性能。而对于系统请求者Client来说，任务一旦提交，Master进程就会立刻分配任务并立即返回，并不会等系统处理完全部任务再返回，其处理过程是异步的。

Master-Worker模式结构

　　Master-Worker模式的主要结构如下图：

　　如上图所示，Master进程是主要进程，它维护着一个Worker进程队列、子任务队列和子结果集，Worker进程中的Worker进程不断的从任务队列中提取要处理的子任务，并将子任务的处理结果放入到子结果集中。

　　在上图中，Master：用于任务的分配和最终结果的合并；Worker：用于实际处理一个任务；客户端进程：用于启动系统，调度开启Master。

Master-Worker模式代码实现

　　Master代码实现：

 1 public class Master {

 2     //任务队列

 3     protected Queue<Object> workQueue = new ConcurrentLinkedQueue<Object>();

 4     //worker进程队列

 5     protected Map<String, Thread> threadMap = new HashMap<String, Thread>();

 6     //结果集

 7     protected Map<String, Object> resultMap = new HashMap<String,Object>();

 8

 9     //是否所有的子任务都结束

10

11     public boolean isComplete(){

12         for(Map.Entry<String, Thread> entry:threadMap.entrySet()){

13             if(entry.getValue().getState()!=Thread.State.TERMINATED){

14                 return false;

15             }

16         }

17         return true;

18     }

19

20     public Master(Worker worker,int countWorker) {

21         worker.setResultMap(resultMap);

22         worker.setWorkQueue(workQueue);

23         for (int i = 0; i < countWorker; i++) {

24             threadMap.put(Integer.toString(i), new Thread(worker,Integer.toString(i)));

25         }

26     }

27

28     //提交任务

29

30     public void submit(Object obj){

31         workQueue.add(obj);

32         //System.out.println(obj.toString());

33     }

34

35

36

37     //返回子任务结果集

38     public Map<String, Object> getResultMap() {

39         return resultMap;

40     }

41

42     //开始运行所有worker进程，并进行处理

43

44     public void execute(){

45         for(Map.Entry<String, Thread> entry:threadMap.entrySet()){

46             entry.getValue().start();

47         }

48     }

49

50 }

　　Worker代码实现：

 1 public class Worker implements Runnable {

 2     //任务队列

 3     protected Queue<Object> workQueue;

 4     //子任务结果集

 5     protected Map<String,Object> resultMap = new HashMap<String, Object>();

 6

 7

 8     public void setWorkQueue(Queue<Object> workQueue) {

 9         this.workQueue = workQueue;

10     }

11     public void setResultMap(Map<String, Object> resultMap) {

12         this.resultMap = resultMap;

13     }

14

15     public Object handle(Object input){

16         return input;

17     }

18     @Override

19     public void run() {

20         while(true){

21             Object input = workQueue.poll();

22

23             if(null==input) break;

24             //处理子任务

25             Object re = handle(input);

26             resultMap.put(Integer.toString(input.hashCode()),re);

27             //System.out.println(re.toString());

28         }

29     }

30

31 }

　　Master-Worker模式是一种串行任务并行化的方法，被分解的子任务在系统中可以并行处理。同时，如果有需要，Master进程不需要所有子任务都执行完成，就可以根据已有的部分结果集计算最终的结果。

　　现在以上面的Master-Worker实现为基础，来实现计算1-100的立方和。计算将被分解为100个子任务，每个子任务仅用于计算单独的立方和。Master产生固定数目Worker，来处理这些子任务。Worker不断的从任务集合中取出这些计算立方和的子任务，并将计算结果放入到Master的结果集中。Master负责将所有Worker的任务结果进行累加，从而产生最终的立方和。整个计算过程，Worker和Master的运算也是完全异步的，Master进程不必等所有的Worker进程都执行完成，就可以进行求和操作了。也就是所，Master在获取部分子任务的结果集时，就可以对最终结果进行计算了，从而提高了系统的并发性和吞吐量。

　　计算子任务的实现如下：

1 public class PlusWorker extends Worker {

2

3     @Override

4     public Object handle(Object input) {

5         Integer i = (Integer) input;

6         return i*i*i;

7     }

8

9 }

　　客户端代码如下：

 1 public class Client {

 2     public static void main(String[] args) {

 3         Master m = new Master(new PlusWorker(), 5);//启动五个线程处理

 4         for (int i = 0; i < 100; i++) {

 5             m.submit(i);

 6         }

 7         m.execute();

 8         int re = 0;

 9         Map<String, Object> resultMap = m.getResultMap();

10         while(resultMap.size()>0||!m.isComplete()){

11             Set<String> keys = resultMap.keySet();

12             String key =  null;

13             for(String k:keys){

14                 key=k;

15                 break;

16             }

17             Integer i = null;

18             if(key != null){

19                 i = (Integer) resultMap.get(key);

20             }

21             if(i!=null){

22                 re+=i;//并行计算结果集

23             }

24

25             if(key!=null){

26                 resultMap.remove(key);//将计算完成的结果移除

27             }

28         }

29

30         System.out.println(re);

31     }

32 }

　　通过Master创建5个Worker工作线程和PlusWorker工作实例。提交完100个任务后，就开始计算子任务。这些子任务，由生成的5个Worker线程共同完成。Master并不等所有的子任务都计算完成，就开始访问子结果集进行最终结果的计算，直到子结果集中所有的数据都被处理，并且5个活跃的Worker线程全部终止，才能求出最终结果。

巴特西

转 Master-Worker模式并行程序设计模式--Master-Worker模式

最新文章

热门文章

巴特西

转 Master-Worker模式 并行程序设计模式--Master-Worker模式

最新文章

热门文章

转 Master-Worker模式并行程序设计模式--Master-Worker模式