python queue windows_python分布式进程（windows下）

分布式进程：

在Thread和Process中，应当优选Process，因为Process更稳定，而且，Process可以分布到多台机器上，而Thread最多只能分布到同一台机器的多个CPU上。

Python的multiprocessing模块不但支持多进程，其中managers子模块还支持把多进程分布到多台机器上。一个服务进程可以作为调度者，将任务分布到其他多个进程中，依靠网络通信。由于managers模块封装很好，不必了解网络通信的细节，就可以很容易地编写分布式多进程程序。

举个例子：如果我们已经有一个通过Queue通信的多进程程序在同一台机器上运行，现在，由于处理任务的进程任务繁重，希望把发送任务的进程和处理任务的进程分布到两台机器上。怎么用分布式进程实现？

原有的Queue可以继续使用，但是，通过managers模块把Queue通过网络暴露出去，就可以让其他机器的进程访问Queue了。

我们先看服务进程，服务进程负责启动Queue，把Queue注册到网络上，然后往Queue里面写入任务：

#coding=utf-8

importrandom, time, Queuefrom multiprocessing.managers importBaseManager#发送任务的队列:

task_queue =Queue.Queue()#接收结果的队列:

result_queue =Queue.Queue()#从BaseManager继承的QueueManager:

classQueueManager(BaseManager):pass

#把两个Queue都注册到网络上, callable参数关联了Queue对象:

QueueManager.register('get_task_queue', callable=lambda: 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 results...')for i in range(10):

r= result.get(timeout=10)print('Result: %s' %r)#关闭:

manager.shutdown()print('master exit.')

在windows命令行终端的运行结果：

由错误信息改代码：

#coding=utf-8

importrandom,time, Queuefrom multiprocessing.managers importBaseManagerfrom multiprocessing importfreeze_support

task_queue= Queue.Queue() #发送任务的队列:

result_queue = Queue.Queue() #接收结果的队列:

class QueueManager(BaseManager): #从BaseManager继承的QueueManager:

pass

#windows下运行

defreturn_task_queue():globaltask_queuereturn task_queue #返回发送任务队列

defreturn_result_queue ():globalresult_queuereturn result_queue #返回接收结果队列

deftest():#把两个Queue都注册到网络上, callable参数关联了Queue对象,它们用来进行进程间通信，交换对象

#QueueManager.register('get_task_queue', callable=lambda: task_queue)

#QueueManager.register('get_result_queue', callable=lambda: result_queue)

QueueManager.register('get_task_queue', callable=return_task_queue)

QueueManager.register('get_result_queue', callable=return_result_queue)#绑定端口5000, 设置验证码'abc':

#manager = QueueManager(address=('', 5000), authkey=b'abc')

#windows需要写ip地址

manager = QueueManager(address=('127.0.0.1', 5000), authkey=b'abc')

manager.start()#启动Queue:

#获得通过网络访问的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 results...')for i in range(10):#这里加了异常捕获

try:

r= result.get(timeout=5)print('Result: %s' %r)exceptQueue.Empty:print('result queue is empty.')#关闭:

manager.shutdown()print('master exit.')if __name__=='__main__':

freeze_support()print('start!')

test()

运行结果：

start!

Put task 968...

Put task 6566...

Put task 711...

Put task 1686...

Put task 4962...

Put task 8514...

Put task 9725...

Put task 4985...

Put task 3896...

Put task 317...

Try get results...

result queue is empty.

result queue is empty.

result queue is empty.

result queue is empty.

result queue is empty.

result queue is empty.

result queue is empty.

result queue is empty.

result queue is empty.

result queue is empty.

master exit.

对比上段代码改变的地方有：

#把两个Queue都注册到网络上, callable参数关联了Queue对象

QueueManager.register('get_task_queue',callable=return_task_queue)

QueueManager.register('get_result_queue',callable=return_result_queue)

其中task_queue和result_queue是两个队列，分别存放任务和结果。它们用来进行进程间通信，交换对象。

官网上有如下例子。

#coding=utf-8

from multiprocessing importProcess, Queuedeff(queue):

queue.put([42, None, 'hello'])if __name__ == '__main__':

q= Queue() #创建队列q

p = Process(target=f, args=(q,)) #创建一个进程

p.start()print(q.get()) #打印列表[42, None, 'hello']

p.join()

其中列表[42, None, ‘hello’]从新建p进程传到了主进程中。

因为是分布式的环境，放入queue中的数据需要等待Workers机器运算处理后再进行读取，这样就需要对queue用QueueManager进行封装放到网络中。这是通过下面这句

QueueManager.register('get_task_queue',callable=return_task_queue)

实现的，我们给return_task_queue的网络调用接口取了一个名get_task_queue,而return_result_queue的名字是get_result_queue，方便区分对哪个queue进行操作。

task.put(n)即是对task_queue进行写入数据，相当于分配任务。而result.get()即是等待workers处理后返回的结果

#windows需要写ip地址

manager = QueueManager(address=('127.0.0.1', 5000), authkey=b'abc')

这点不同于linux操作系统，必须写ip地址

if __name__=='__main__':

freeze_support()print('start!')

test()

windows必须有 if name==’main‘: 这点从报错的信息可以看出

中间加入了捕获异常，使代码运行完整，运行结果更容易看懂，在运行的时候最好用cmd终端。

下面是Worker的代码：

#coding=utf-8

importtime, sys,Queuefrom multiprocessing.managers importBaseManager#创建类似的QueueManager:

classQueueManager(BaseManager):pass

#由于这个QueueManager只从网络上获取Queue，所以注册时只提供名字:

QueueManager.register('get_task_queue')

QueueManager.register('get_result_queue')#连接到服务器，也就是运行task_master.py的机器:

server_addr = '127.0.0.1'

print('Connect to server %s...' %server_addr)#端口和验证码注意保持与task_master.py设置的完全一致:

m = QueueManager(address=(server_addr, 5000), authkey=b'abc')#从网络连接:

try:

m.connect()except:print('请先启动task_master.py!')#sys.exit("sorry, goodbye!");#获取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...' %(n, n))

r= '%d * %d = %d' % (n, n, n*n)

time.sleep(1)

result.put(r)exceptQueue.Empty:print('task queue is empty.')#处理结束:

print('worker exit.')

这个简单的Master/Worker模型有什么用？其实这就是一个简单但真正的分布式计算，把代码稍加改造，启动多个worker，就可以把任务分布到几台甚至几十台机器上，比如把计算n*n的代码换成发送邮件，就实现了邮件队列的异步发送。

Queue对象存储在哪？注意到task_worker.py中根本没有创建Queue的代码，所以，Queue对象存储在task_master.py进程中：

task_worker这里的QueueManager注册的名字必须和task_manager中的一样。对比上面的例子，可以看出Queue对象从另一个进程通过网络传递了过来。只不过这里的传递和网络通信由QueueManager完成。

运行结果：

运行task_master.py

运行task_worker.py