Master-Worker

这种模型是最常用的并行模式之一，在Nginx源码中有涉及到有想看的可以去这个大神的博客了解一下http://blog.csdn.net/marcky/article/details/6014733，这位大神写的有些简洁。从思想的角度来说，它主要由两类进程进行协作：分别是Master进程和Worker进程。Master进程负责接受和分配任务，Worker进程负责处理子任务，当Worker将子任务处理完成后，将结果返回给Master进程，由Master进程做归纳和汇总，得到最终结果，具体流程可以看此图

这种模式能够将一个大任务分解成若干个小任务去执行，适合一些耗时比较久的任务，能够提高系统的吞吐量。

一个相对完整的模型应该具备以下功能

在借鉴了Java性能优化书上的列子，上面实现了一个简单的Master-Worker模式

[java] view plain copy

 print?

1. package com.thread;  
2.   
3. import java.util.HashMap;  
4. import java.util.Iterator;  
5. import java.util.Map;  
6. import java.util.Queue;  
7. import java.util.Set;  
8. import java.util.concurrent.ConcurrentHashMap;  
9. import java.util.concurrent.ConcurrentLinkedDeque;  
10.   
11. public class Master_Worker {  
12.     public static void main(String args[])  
13.      {  
14.           long start = System.currentTimeMillis();  
15.          Master_Worker master_Worker = new Master_Worker(new PlusWorker(), 11);  
16.          for (int i = 0; i < 100; i++) {  
17.             master_Worker.submit(i);  
18.         }  
19.          master_Worker.execute();  
20.          int re = 0;  
21.          Map<String, Object> result_Map = master_Worker.getResultMap();  
22.          while (result_Map.size()>0||!master_Worker.isComplete()) {  
23.              Set<String> keysSet = result_Map.keySet();  
24.              String keyString = null;  
25.              for (String string : keysSet) {  
26.                 keyString = string;  
27.                 break;  
28.             }  
29.              Integer i = null;  
30.              if (keyString !=null) {  
31.                 i = (Integer) result_Map.get(keyString);  
32.             }  
33.              if (i!=null) {  
34.                 re+=i;  
35.             }  
36.              if (keyString!=null) {  
37.                 result_Map.remove(keyString);  
38.             }  
39.         }  
40.          long end = System.currentTimeMillis();  
41.          System.out.println("结果："+re+"-执行之间"+(end-start));  
42.          int sum = 0;  
43.          start = System.currentTimeMillis();  
44.          for (int i = 1; i <= 100; i++) {  
45.             sum+=i*i*i;  
46.             try {  
47.                 Thread.sleep(100);  
48.             } catch (InterruptedException e) {  
49.                 // TODO Auto-generated catch block  
50.                 e.printStackTrace();  
51.             }  
52.         }  
53.          end = System.currentTimeMillis();  
54.          System.out.println("结果："+sum+"-执行之间"+(end-start));  
55.      }  
56.     // 任务队列  
57.     protected Queue<Object> workerQueue = new ConcurrentLinkedDeque<>();  
58.     // Worker进程队列  
59.     protected Map<String, Thread> threadMap = new HashMap<>();  
60.     // 子任务处理结果集  
61.     protected Map<String, Object> resultMap = new ConcurrentHashMap<>();  
62.   
63.     // 是否所有的子任务都结束了  
64.     public boolean isComplete() {  
65.         for (Map.Entry<String, Thread> entry : threadMap.entrySet()) {  
66.             if (entry.getValue().getState() != Thread.State.TERMINATED) {  
67.                 return false;  
68.             }  
69.         }  
70.         return true;  
71.     }  
72.   
73.     // Master的构造，需要一个Worker进程逻辑，和需要的Worker进程数量  
74.     public Master_Worker(Worker woker, int countWorker) {  
75.         woker.setWorkQueue(workerQueue);  
76.         woker.setResultMap(resultMap);  
77.         for (int i = 0; i < countWorker; i++) {  
78.             threadMap.put(Integer.toString(i),  
79.                     new Thread(woker, Integer.toString(i)));  
80.         }  
81.   
82.     }  
83.   
84.     //返回子任务结果集  
85.     public Map<String, Object> getResultMap()  
86.     {  
87.         return resultMap;  
88.     }  
89.     //提交任务  
90.     public void submit(Object job) {  
91.         workerQueue.add(job);  
92.     }  
93.     public void execute()  
94.     {  
95.         for (Map.Entry<String, Thread> entry : threadMap.entrySet()) {  
96.             if (entry.getValue().getState() != Thread.State.TERMINATED) {  
97.                 entry.getValue().start();  
98.             }  
99.         }  
100.     }  
101. }  
102.   
103. class Worker implements Runnable {  
104.   
105.     // 任务队列，用于取得子任务  
106.     protected Queue<Object> workQueue;  
107.     // 子任务处理结果集  
108.     protected Map<String, Object> resultMap;  
109.   
110.     public void setWorkQueue(Queue<Object> workQueue) {  
111.         this.workQueue = workQueue;  
112.     }  
113.   
114.     public void setResultMap(Map<String, Object> resultMap) {  
115.         this.resultMap = resultMap;  
116.     }  
117.   
118.     // 子任务处理逻辑，在子类中实现具体逻辑  
119.     public Object handle(Object input) {  
120.         /* 这里可以写自己想要做的事情 */  
121.         return input;  
122.     }  
123.   
124.     @Override  
125.     public void run() {  
126.         // TODO Auto-generated method stub  
127.         while (true) {  
128.             // 获取子任务  
129.             Object inputObject = workQueue.poll();  
130.             if (inputObject == null) {  
131.                 break;  
132.             }  
133.             // 处理子任务  
134.             Object reObject = handle(inputObject);  
135.             resultMap.put(Integer.toString(inputObject.hashCode()), reObject);  
136.         }  
137.     }  
138. }  
139.   
140. /* 
141.  * 扩展自己的类 
142.  * */  
143.  class PlusWorker extends Worker{  
144.      @Override  
145.     public Object handle(Object input) {  
146.         // TODO Auto-generated method stub  
147.          //在这里可以自己实现自己的业务逻辑等，在这里我让线程睡眠了100毫秒，模拟任务执行  
148.            
149.          try {  
150.             Thread.sleep(100);  
151.         } catch (InterruptedException e) {  
152.             // TODO Auto-generated catch block  
153.             e.printStackTrace();  
154.         }  
155.         Integer i = (Integer) input;  
156.         return i*i*i;  
157.     }  
158.  }  
159.    
160.    

这里的大多数都是借鉴java性能优化一书，加上自己的改编和简介。

-----------------------------------------------------------------------------------------------------------------------------------------------------

 

java 多线程 master worker模式

2013-11-01 10:23 533人阅读 评论(0) 收藏 举报

 分类：

 

java（55） 

版权声明：本文为博主原创文章，未经博主允许不得转载。

[java] view plain copy

1. package com.example.design.master_worker;  
2.   
3. import java.lang.Thread.State;  
4. import java.util.ArrayList;  
5. import java.util.HashMap;  
6. import java.util.LinkedHashMap;  
7. import java.util.List;  
8. import java.util.Map;  
9. import java.util.Queue;  
10. import java.util.concurrent.LinkedBlockingQueue;  
11.   
12. public class Master {  
13.     /** 
14.      * 要做的事 
15.      */  
16.     Queue<Work> works = new LinkedBlockingQueue<Work>();  
17.   
18.     /** 
19.      * 分配几个人来做相当于工人 
20.      */  
21.     List<Thread> Workers = new ArrayList<Thread>();  
22.     /** 
23.      * 结果 key对应的事 value事的结果 
24.      */  
25.     ArrayList<Object> results = new ArrayList<Object>();  
26.   
27.     public Master(int runCount, Worker worker) {  
28.         worker.setValue(works, results);  
29.         for (int i = 0; i <= runCount; i++) {  
30.             Workers.add(new Thread(worker));  
31.         }  
32.     }  
33.   
34.     public void submit(Work w) {  
35.         works.add(w);  
36.     }  
37.   
38.     public void execute() {  
39.         for (Thread run : Workers) {  
40.             run.start();  
41.         }  
42.     }  
43.   
44.     /** 
45.      * 判断线程是否全部终止 
46.      *  
47.      * @return true 有未完成 
48.      */  
49.     public boolean checkIsComplete() {  
50.         for (Thread run : Workers) {  
51.             if ((run.getState() != State.TERMINATED)) {  
52.                 return true;  
53.             }  
54.         }  
55.         return false;  
56.     }  
57. }  

[java] view plain copy

1.   

[java] view plain copy

1. package com.example.design.master_worker;  
2.   
3. public abstract class Work {  
4.     Object obj;  
5.   
6.     public Work(Object obj) {  
7.         super();  
8.         this.obj = obj;  
9.     }  
10.   
11.     public abstract Object handler();  
12.   
13.     public Object getParm() {  
14.         return obj;  
15.     };  
16. }  

[java] view plain copy

1. package com.example.design.master_worker;  
2.   
3.   
4. import java.util.ArrayList;  
5. import java.util.Map;  
6. import java.util.Queue;  
7.   
8.   
9. public class Worker implements Runnable {  
10.     Queue<Work> works;  
11.     ArrayList<Object> results;  
12.   
13.   
14.     public void setValue(Queue<Work> works, ArrayList<Object> results) {  
15.         this.works = works;  
16.         this.results = results;  
17.     }  
18.   
19.   
20.     @Override  
21.     public void run() {  
22.         while (true) {  
23.             Work work = works.poll();  
24.             if (work == null) {  
25.                 break;  
26.             }  
27.             Object result = work.handler();  
28.             results.add(result);  
29.         }  
30.     }  
31. }  

[java] view plain copy

1. package com.example.design.master_worker;  
2.   
3. public class Work1 extends Work {  
4.   
5.     public Work1(Object obj) {  
6.         super(obj);  
7.     }  
8.   
9.     @Override  
10.     public Object handler() {  
11.         int i = (Integer) obj;  
12.         int t = i * i * i;  
13.         return t;  
14.     }  
15. }  

[java] view plain copy

1. private static void masterTest(int t) {  
2.         Worker worker = new Worker();  
3.         Master master = new Master(5, worker);  
4.         for (int i = 0; i <= t; i++) {  
5.             master.submit(new Work1(i));  
6.         }  
7.         master.execute();  
8.         int result = 0;  
9.   
10.         ArrayList<Object> results = master.results;  
11.         while (results.size() > 0 || master.checkIsComplete()) {  
12.             if (results.size() > 0) {  
13.                 result += (Integer) results.remove(0);  
14.             }  
15.         }  
16.         System.out.println(result);  
17.     }