python的多进程
Python基础-分布式进程 Master/Worker模型
2017年12月17日 22:39:43 法迪 阅读数：617
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/su749520/article/details/78828679
分布式进程
Python的multiprocessing模块不但支持多进程，其中的managers子模块还支持吧多进程分布到多台机器上。
Demo
只能在unix(类unix)环境运行，windows会报错
具体解释
https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431929340191970154d52b9d484b88a7b343708fcc60000#0
运行示例
服务端
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 分布进程-服务端
import random, time, queue
from multiprocessing.managers import BaseManager
# 发送任务的队列
task_queue = queue.Queue()
# 接收任务的队列
result_queue = queue.Queue()
# 从 BaseManager继承的 QueueManager
class QueueManager(BaseManager):
pass
def get_task_queue():
global task_queue
return task_queue
# 把两个Queue都注册到网络上,callable参数关联了 Queue 对象
QueueManager.register("get_task_queue", callable = get_task_queue)
QueueManager.register("get_result_queue", callable = lambda:result_queue)
# 绑定端口5000，设置验证码为"abc"
manager = QueueManager(address=("", 5000), authkey=b"abc")
# 启动 Queue
manager.start()
# 获取通过网络访问的 Queue 对象
task = manager.get_task_queue()
result = manager.get_result_queue()
# 放几个任务进去
for i in range(10):
n = random.randint(0, 10000)
print("Put task %d" % n)
task.put(n)
# 从result队列中读取结果
print("Try get result")
for i in range(10):
r = result.get(timeout = 10)
print("结果 %s" % r)
# 关闭
manager.shutdown()
print("manage exit")客户端
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 分布进程-客户端
import time, sys, queue
from multiprocessing.managers import BaseManager
# 创建类似的 QueueManager
class QueueManager(BaseManager):
pass
# 由于这个QueueManager只从网络上获取Queue,所以注册时只提供名字
QueueManager.register("get_task_queue")
QueueManager.register("get_result_queue")
# 连接到服务器，即运行 task_master.py 的机器
server_addr = "127.0.0.1"
print("连接服务器 %s" % server_addr)
# 端口和验证码注意和服务器一致
m = QueueManager(address=(server_addr, 5000), authkey=b'abc')
# 从网络连接:
m.connect()
# 获取Queue的对象
task = m.get_task_queue()
result = m.get_result_queue()
# 从 task 队列中取任务，并把结果写入result队列
for i in range(10):
try:
n = task.get(timeout = 1)
print("run task %d * %d" %d (n, n))
r = "%d * %d = %d " % (n, n, n * n)
time.sleep(1)
result.put(r)
except Queue.Empty:
print("task queue is empty")Window无法正常执行，例如
D:\PythonProject>Traceback (most recent call last):
File "<string>", line 1, in <module>
File "C:\ProgramData\Anaconda3\lib\multiprocessing\spawn.py", line 99, in spawn_main
new_handle = reduction.steal_handle(parent_pid, pipe_handle)
File "C:\ProgramData\Anaconda3\lib\multiprocessing\reduction.py", line 82, in steal_handle
_winapi.PROCESS_DUP_HANDLE, False, source_pid)
OSError: [WinError 87] 参数错误。
python task_worker.py
连接服务器 127.0.0.1
Traceback (most recent call last):
File "task_worker.py", line 23, in <module>
m.connect()
File "C:\ProgramData\Anaconda3\lib\multiprocessing\managers.py", line 489, in connect
conn = Client(self._address, authkey=self._authkey)
File "C:\ProgramData\Anaconda3\lib\multiprocessing\connection.py", line 487, in Client
c = SocketClient(address)
File "C:\ProgramData\Anaconda3\lib\multiprocessing\connection.py", line 614, in SocketClient
s.connect(address)
ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝，无法连接。这个简单的Master/Worker模型有什么用？其实这就是一个简单但真正的分布式计算，把代码稍加改造，启动多个worker，就可以把任务分布到几台甚至几十台机器上，比如把计算n*n的代码换成发送邮件，就实现了邮件队列的异步发送。
看来这个demo暂时无法看效果了，可惜
====================================================================================================================================================================================================================================================================================================================================================================
Master-Worker设计模式
2016年09月30日 06:33:16 WaveVector 阅读数：4152
@(分布式计算集群)
Master-Worker设计模式在生活中非常地常见，比如：督工和工人，督工给每个工人分配任务，也监督每个工人的工作情况。一般还有以下场景：如果有个工人身体不好，就重新将他的任务分配给其他人；现实中一般督工就一个，督工自己也有可能身体不好，然后呢？就没有然后了——也有可能由一个工人暂时顶替，或者再从其他小组挪一个督工，或者由一直陪同的小秘顶上。额外补充的场景是为了能够应对不正常事件，保证任务能够准时完成。同样的，程序设计中，也有这样的场景存在，尤其是任务量很大的时候。那我们是怎样完成这样的场景抽象，又是如何保证异常问题下的正常任务执行的呢？Hadoop中的Master-Worker设计模式又是怎么指导MapReduce工作流程的？
##Master-Worker设计模式介绍
Master-Worker模式是常用的并行设计模式。核心思想是，系统由两个角色组成，Master和Worker，Master负责接收和分配任务，Worker负责处理子任务。任务处理过程中，Master还负责监督任务进展和Worker的健康状态；Master将接收Client提交的任务，并将任务的进展汇总反馈给Client。各角色关系如下图
Master-Worker模式满足于可以将大任务划分为小任务的场景，是一种分而治之的设计理念。通过多线程或者多进程多机器的模式，可以将小任务处理分发给更多的CPU处理，降低单个CPU的计算量，通过并发/并行提高任务的完成速度，提高系统的性能。
具体细节如上图，Master对任务进行切分，并放入任务队列；然后，触发Worker处理任务。实际操作中，任务的分配有多种形式，如Master主动拉起Workder进程池或线程池，并将任务分配给Worker；或者由Worker主动领取任务，这样的Worker一般是常驻进程；还有一种解耦的方式，即Master指做任务的接收、切分和结果统计，指定Worker的数量和性能指标，但不参与Worker的实际管理，而是交由第三方调度监控和调度Worker。
##用例说明
###1. 简单demo(来自网友编写，做了些细节调整)
####Master类定义
package com.linesum.linjx.test.masterWorker;
import java.util.HashMap;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicLong;
/**
* Master定义
* @author linjx
* @Date 2016年9月22日
*/
public class Master {
/**
* 任务列表(这边作为Master成员变量，可以拆分)
*/
private Queue<Object> jobQueue = new ConcurrentLinkedQueue<Object>();
/**
* Worker组
*/
private Map<String, Thread> workers = new HashMap<>();
/**
* 结果集(这边作为Master成员变量，可以拆分)
*/
private Queue<Object> results = new ConcurrentLinkedQueue<Object>();
/**
* 原始任务数
*/
private AtomicLong oriJobNum = new AtomicLong(0);
/**
* @param workerNum，worker数量上限
* @param workerClass, worker实现类
* @throws IllegalAccessException
* @throws InstantiationException
*/
public Master(int workerNum, Class<? extends Worker> workerClass)
throws InstantiationException, IllegalAccessException {
for (int i = 0; i < workerNum; i ++) {
Worker worker = workerClass.newInstance();
worker.setJobQueue(jobQueue);
worker.setResults(results);
worker.setId(i);
workers.put(Integer.toString(i),
new Thread(worker, Integer.toString(i)));
}
}
/**
* 任务是否已经完成
* @return
*/
public boolean isComplete() {
for (Map.Entry<String, Thread> worker : workers.entrySet()) {
if (Thread.State.TERMINATED != worker.getValue().getState()) {
return false;
}
}
return true;
}
/**
* 由Client提交一个子任务
* @param job
*/
public void submit(Object job) {
oriJobNum.incrementAndGet(); //允许动态增加任务
jobQueue.add(job);
}
/**
* 返回子任务结果集
* @return
*/
public Queue<Object> getResults() {
return results;
}
/**
* 将运行结果放到结果集
* @param result
*/
public void putResult(Object result) {
results.add(result);
}
/**
* 启动worker，进行任务处理
*/
public void execute() {
for(Map.Entry<String, Thread> entry : workers.entrySet()) {
entry.getValue().start();
}
}
/**
* 获取完成任务占比
* @return
*/
public float getFinishRatio() {
return 100.0f-100.0f * ((float)jobQueue.size()) / oriJobNum.get();
}
}
####Worker类定义
package com.linesum.linjx.test.masterWorker;
import java.util.Queue;
/**
* Worker
* @author linjx
* @Date 2016年9月22日
*/
public abstract class Worker implements Runnable {
/**
* id
*/
private int id;
/**
* 任务队列
*/
protected Queue<Object> jobs;
/**
* 子任务结果集
*/
protected Queue<Object> results;
public abstract Object handle(Object input);
@Override
public void run() {
System.out.println(String.format("Worker:[%d] start working...", this.id));
while(true){
Object input = jobs.poll(); //贪婪式获取任务
if(null == input) break;
//处理子任务，并传递给结果集
putResult(handle(input));
}
System.out.println(String.format("Worker:[%d] finish the jobs...", this.id));
}
public void setJobQueue(Queue<Object> jobQueue) {
this.jobs = jobQueue;
}
public void setResults(Queue<Object> results) {
this.results = results;
}
private void putResult(Object result) {
results.add(result);
}
public void setId(int id) {
this.id = id;
}
}
上述定义，与网友定义有些出入，做了些调整和丰富。这里，做个Worker用例，使用Master-Worker实现∑Ni=0n3i
∑i=0Nni3 的计算。OK，分而治之的理念，即每个worker获取任务ni
ni，然后计算$ n_i^3$，并将结果放入结果集。
####PlusWorker定义
package com.linesum.linjx.test.job;
import com.linesum.linjx.test.masterWorker.Worker;
/**
* 求立方和
* @author linjx
* @Date 2016年9月22日
*/
public class PlusWorker extends Worker {
@Override
public Object handle(Object input) {
long i = (Long) input;
return i * i * i;
}
}
####Client实现
package com.linesum.linjx.test.job;
import java.util.Queue;
import com.linesum.linjx.test.masterWorker.Master;
/**
* Client
* @author linjx
* @Date 2016年9月22日
*/
public class Client {
private static int jobNum = 500000;
public static void main(String args[]) throws InterruptedException {
testMasterWorker();
System.out.println("-----------------");
testSington();
}
static void testMasterWorker() throws InterruptedException {
//固定使用4个Workder
Master master = null;
try {
master = new Master(4, PlusWorker.class);
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
System.exit(1);
}
for(long i = 1; i <= jobNum; i ++) //提交100个子任务
master.submit(i);
master.execute(); //开始计算
long re = 0;
while(true) {
if(master.isComplete()) {//等待计算结束
Queue<Object> results = master.getResults();
for (Object result : results) {
re = re + (long) result;
}
System.out.println(master.getFinishRatio() + "%");
break;
} else {
System.out.println(master.getFinishRatio() + "%");
Thread.sleep(1);
}
}
System.out.println(re);
}
static void testSington() {
long result = 0;
for (long i = 1; i <= jobNum; i ++) {
result = result + (i*i*i);
}
System.out.println(result);
}
}
这个是模拟网友实现的，各位有没有觉得有点怪异，最后的累加居然是由Client来做的，而不是Master来完成的，明显不合理啊。和MapReduce做比较，我们会发现，PlusWorker只是实现了基本的Map功能，我们并没有考虑聚合Reduce的实现。好的，我没有打算再拓展这个用例，就用了一个MapReduce的经典Demo来重新实现我的Master-Worker，具体如下：
###2. 词频计数demo(可以更合理的将Map和Reduce拆分成两个worker)
词频计算是一个非常常见的用例，这里就不多做赘述。具体实现如下
####新增Worker构造方法
/**
* @param workerNum，worker数量上限
* @param workerClass, worker实现类
* @Param jobQueue, 任务队列
* @Param resultQueue, 结果集队列
* @throws IllegalAccessException
* @throws InstantiationException
*/
public Master(int workerNum, Class<? extends Worker> workerClass,
Queue<Object> jobQueue, Queue<Object> resultQueue)
throws InstantiationException, IllegalAccessException {
for (int i = 0; i < workerNum; i ++) {
Worker worker = workerClass.newInstance();
worker.setJobQueue(jobQueue);
worker.setResults(resultQueue);
worker.setId(i);
workers.put(Integer.toString(i),
new Thread(worker, Integer.toString(i)));
}
}
####改造Master
/**
*
*/
package com.linesum.linjx.test.masterWorker;
import java.util.HashMap;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicLong;
/**
* Master定义
* @author linjx
* @Date 2016年9月22日
*/
public class Master {
/**
* 任务列表
*/
private Queue<Object> jobQueue = new ConcurrentLinkedQueue<Object>();
/**
* Worker组
*/
private Map<String, Thread> workers = new HashMap<>();
/**
* 结果集
*/
private Queue<Object> results = new ConcurrentLinkedQueue<Object>();
/**
* 原始任务数
*/
private AtomicLong oriJobNum = new AtomicLong(0);
public Master() {}
/**
* @param workerNum，worker数量上限
* @param workerClass, worker实现类
* @throws IllegalAccessException
* @throws InstantiationException
*/
public Master(int workerNum, Class<? extends Worker> workerClass)
throws InstantiationException, IllegalAccessException {
for (int i = 0; i < workerNum; i ++) {
Worker worker = workerClass.newInstance();
worker.setJobQueue(jobQueue);
worker.setResults(results);
worker.setId(i);
workers.put(Integer.toString(i),
new Thread(worker, Integer.toString(i)));
}
}
/**
* @param workerNum，worker数量上限
* @param workerClass, worker实现类
* @Param jobQueue, 任务队列
* @Param resultQueue, 结果集队列
* @throws IllegalAccessException
* @throws InstantiationException
*/
public Master(int workerNum, Class<? extends Worker> workerClass,
Queue<Object> jobQueue, Queue<Object> resultQueue)
throws InstantiationException, IllegalAccessException {
for (int i = 0; i < workerNum; i ++) {
Worker worker = workerClass.newInstance();
worker.setJobQueue(jobQueue);
worker.setResults(resultQueue);
worker.setId(i);
workers.put(Integer.toString(i),
new Thread(worker, Integer.toString(i)));
}
}
/**
* 任务是否已经完成
* @return
*/
public boolean isComplete() {
for (Map.Entry<String, Thread> worker : workers.entrySet()) {
if (Thread.State.TERMINATED != worker.getValue().getState()) {
return false;
}
}
return true;
}
/**
* 任务是否已经完成
* @return
*/
public boolean isComplete(Map<String, Thread> workers) {
for (Map.Entry<String, Thread> worker : workers.entrySet()) {
if (Thread.State.TERMINATED != worker.getValue().getState()) {
return false;
}
}
return true;
}
/**
* 由Client提交一个子任务
* @param job
*/
public void submit(Object job) {
oriJobNum.incrementAndGet(); //允许动态增加任务
jobQueue.add(job);
}
public Queue<Object> getJobs() {
return jobQueue;
}
/**
* 返回子任务结果集
* @return
*/
public Queue<Object> getResults() {
return results;
}
/**
* 将运行结果放到结果集
* @param result
*/
public void putResult(Object result) {
results.add(result);
}
/**
* 启动worker，进行任务处理
*/
public void execute() {
for(Map.Entry<String, Thread> entry : this.workers.entrySet()) {
entry.getValue().start();
}
}
/**
* 启动特定的worker,进行任务处理
* @param workers
*/
public void execute(Map<String, Thread> workers) {
for(Map.Entry<String, Thread> entry : workers.entrySet()) {
entry.getValue().start();
}
}
/**
* 获取完成任务占比
* @return
*/
public float getFinishRatio() {
return 100.0f-100.0f * ((float)jobQueue.size()) / oriJobNum.get();
}
}
####定义WordCountMapper
/**
*
*/
package com.linesum.linjx.test.job;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import com.linesum.linjx.test.masterWorker.Worker;
/**
*
* @author linjx
* @Date 2016年9月22日
*/
public class WordCountMapper extends Worker {
@Override
public Object handle(Object input) {
Map<String, Integer> wordCount = new HashMap<>();
if (null != input && StringUtils.isNotBlank(String.valueOf(input))) {
String[] words = StringUtils.split(String.valueOf(input), " "); //分词
for (String w : words) {
if (StringUtils.isBlank(w)) {
continue;
}
wordCount.put(w, wordCount.getOrDefault(w, 0) + 1);
}
}
return wordCount;
}
}
####定义WordCountReducer
/**
*
*/
package com.linesum.linjx.test.job;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Queue;
import org.apache.commons.collections4.MapUtils;
import com.linesum.linjx.test.masterWorker.Worker;
/**
* WordCount Reducer
* @author linjx
* @Date 2016年9月27日
*/
public class WordCountReducer extends Worker {
@Override
public void run() {
System.out.println(String.format("Worker:start working..."));
putResult(handle(jobs));
System.out.println(String.format("Worker:finish the jobs..."));
}
@Override
public Object handle(Object input) {
Map<String, Integer> resultMap = new HashMap<>();
for (Object re : (Queue<Object>) input) {
if (MapUtils.isEmpty((Map<?, ?>) re)) {
continue;
}
@SuppressWarnings("unchecked")
Map<String, Integer> reMap = (Map<String, Integer>) re;
for (Entry<String, Integer> entry : reMap.entrySet()) {
resultMap.put(entry.getKey(), resultMap.getOrDefault(entry.getKey(), 0) + entry.getValue());
}
}
return resultMap;
}
}
####定义Job并调度
/**
*
*/
package com.linesum.linjx.test.job;
import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
/**
*
* @author linjx
* @Date 2016年9月22日
*/
public class WordCountJob {
public static void main(String args[]) throws InstantiationException, IllegalAccessException, InterruptedException {
Queue<Object> result = new LinkedBlockingQueue<>();
WordCountMaster master = new WordCountMaster();
master.setMapWorkers(5, WordCountMapper.class, master.getJobs(), master.getResults());
master.setReduceWorkers(1, WordCountReducer.class, master.getResults(), result);
master.submit("hello world1");
master.submit("hello world2");
master.submit("hello world2");
master.submit("hello world3");
master.submit("hello world3");
master.submit("hello world3");
master.submit("hello world4");
master.submit("hello world4");
master.submit("hello world4");
master.submit("hello world4");
master.submit("hello world5");
master.submit("hello world5");
master.submit("hello world5");
master.submit("hello world5");
master.submit("hello world5");
master.map();
while(true) {
//这里是等待结束后才开始执行reduce，改变reduce的统计方式，可以提前执行reduce
if (master.isComplete(master.mapWorkers)) {
System.out.println(master.getFinishRatio() + "%");
master.reduce();
while(true) {
if (master.isComplete(master.reduceWorkers)) {
System.out.println(result);
break;
} else {
Thread.sleep(5);
}
}
break;
} else {
System.out.println(master.getFinishRatio() + "%");
Thread.sleep(5);
}
}
}
}
执行结果如下：
0.0%
Worker:[3] start working...
Worker:[4] start working...
Worker:[2] start working...
Worker:[0] start working...
Worker:[1] start working...
33.333336%
Worker:[0] finish the jobs...
Worker:[3] finish the jobs...
Worker:[4] finish the jobs...
Worker:[2] finish the jobs...
Worker:[1] finish the jobs...
100.0%
Worker:start working...
Worker:finish the jobs...
[{world4=4, world5=5, world2=2, world3=3, hello=15, world1=1}]
这个构造方法是为了满足指定任务集和结果集，即满足更加灵活的任务和结果指定，意味着jobQueue和resultQueue是可以拆分的，比如可以使用File、HDFS、Cache等实现机制。
####WorkCountMaster
####思考
这里的实现还是不够彻底，Map和Reduce集成的类不应该是同一个Worker；Map和Reduce的输入输出没有合理的定义；计算内容存储没有和Master解耦等。这些就留给各位再做优化，这里做个引子而已。
##总结
一个完成的分布式Master-Worker实现是Demo用例没有体现的。高可用的分布式Master-Worker要考虑任务的分配，方式数据倾斜带来的单点等待；考虑单点故障重试和任务重新分配策略；考虑网络传输损耗，避免过多的数据传输和交换；考虑Worker Failure处理机制；考虑Master Failure重试机制；并且还应该考虑更多的可拓展性，比如分区算法、快速排序算法等等问题。这些问题我们将在后续的章节展开讨论。
===========================================================================================================================================================================================================================================================================
java线程深度解析（四）——并发模型（Master-Worker）
2016年05月11日 11:39:52 钟艾伶 阅读数：2053
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Daybreak1209/article/details/51372929
二、Master-worker ——分而治之
Master-worker常用的并行模式之一，核心思想是由两个进程协作工作，master负责接收和分配任务，worker负责处理任务，并把处理结果返回给Master进程，由Master进行汇总，返回给客户端。
它的好处在于能把一个大任务分解成若干个小任务，并行执行，提高系统吞吐量。而对于客户端而言，一旦提交任务，mater进程立刻返回一个处理结果，并非等待系统处理完毕再返回。
下面利用Master-Worker模型实现一个计算1-100立方和，思路如下：
1、将计算任务分配成100个子任务，每个子任务用于计算单独数字的立方和
2、master产生固定个数的worker用于处理这个子任务
3、worker开始计算，并把结果写入resultMap中
4、master负责汇总map中的数据，求和后将最终结果返回给客户端。
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();//remove the head of queue -
if(input==null) break; -
//处理子任务 -
Object re=handle(input); -
//将处理结果写入结果集 -
resultMap.put(Integer.toString(input.hashCode()),re); -
} -
} -
}
Worker子类实现：单个数字立方计算，重写worker的handle方法
-
public class SubWorker extends Worker{ -
public Object handle(Object input) -
{ -
Integer i=(Integer)input; -
return i*i*i; -
} -
}
Master类的实现
-
public class Master { -
//任务队列 -
protected Queue<Object> workQueue=new ConcurrentLinkedQueue<Object>(); -
//work进程队列 -
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); -
System.out.println("任务队列size："+workQueue.size()); -
} -
//返回子任务结果集 -
public Map<String,Object> getResultMap() -
{ -
return resultMap; -
} -
//开始运行所有的worker进程 -
public void execute() -
{ -
for(Map.Entry<String, Thread> entry:threadMap.entrySet()) -
{ -
entry.getValue().start();//调用子线程 worker.run -
System.out.println(entry.getValue()); -
} -
} -
}
客户端实现
-
public class Client { -
public static void main(String[] args) { -
Master master=new Master(new SubWorker(), 5);//指定5个 -
for(int i=0;i<100;i++) -
master.submit(i); -
master.execute(); -
int re=0; -
Map<String,Object> resultMap=master.getResultMap(); -
while(resultMap.size()>0 || !master.isComplete()) -
{ -
//不需要等待所有的worker执行完就可以计算结果 -
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); //打印最后计算结果 -
} -
}
最终结果：
任务队列大小
size：1-100
五个线程数：
Thread[0,5,main]
Thread[1,5,main]
Thread[2,5,main]
Thread[3,5,main]
Thread[4,5,main]
最终计算结果：
24502500
在整个计算中，master和worker 的执行完全是异步的，master不必等到每所有worker完成，就可以进行求和操作。在获得部分子任务结果时，就已经可以对结果进行计算，从而提高并发度和吞吐量。
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
