Python分布式进程中你会遇到的坑

开发 后端 分布式
你是不是在用Python3或者在windows系统上编程?最重要的是你对进程和线程不是很清楚?

 [[266539]]

小惊大怪

你是不是在用Python3或者在windows系统上编程?最重要的是你对进程和线程不是很清楚?那么恭喜你,在python分布式进程中,会有坑等着你去挖。。。(hahahaha,此处允许我吓唬一下你)开玩笑的啦,不过,如果你知道序列中不支持匿名函数,那这个坑就和你say byebye了。好了话不多数,直接进入正题。

分布式进程

正如大家所知道的Process比Thread更稳定,而且Process可以分布到多台机器上,而Thread最多只能分布到同一台机器的多个CPU上。Python的multiprocessing模块不但支持多进程,其中managers子模块还支持把多进程分布到多台机器上。一个服务进程可以作为调度者,将任务分布到其他多个进程中,依靠网络通信。由于managers模块封装很好,不必了解网络通信的细节,就可以很容易地编写分布式多进程程序。

代码记录

举个例子

如果我们已经有一个通过Queue通信的多进程程序在同一台机器上运行,现在,由于处理任务的进程任务繁重,希望把发送任务的进程和处理任务的进程分布到两台机器上,这应该怎么用分布式进程来实现呢?你已经知道了原有的Queue可以继续使用,而且通过managers模块把Queue通过网络暴露出去,就可以让其他机器的进程来访问Queue了。好,那我们就这么干!

写个task_master.py

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

  1. #!/user/bin/pytthon 
  2. # -*- coding:utf-8 -*- 
  3. # @Time: 2018/3/3 16:46 
  4. # @Author: lichexo 
  5. # @File: task_master.py 
  6. import random, time, queue 
  7. from multiprocessing.managers import BaseManager 
  8. # 发送任务的队列: 
  9. task_queue = queue.Queue() 
  10. # 接收结果的队列: 
  11. result_queue = queue.Queue() 
  12. # 从BaseManager继承的QueueManager: 
  13. class QueueManager(BaseManager): 
  14.  pass 
  15. # 把两个Queue都注册到网络上, callable参数关联了Queue对象: 
  16. QueueManager.register('get_task_queue', callable=lambda: task_queue) 
  17. QueueManager.register('get_result_queue', callable=lambda: result_queue) 
  18. # 绑定端口5000, 设置验证码'abc'
  19. manager = QueueManager(address=('', 5000), authkey=b'abc'
  20. # 启动Queue: 
  21. manager.start() 
  22. # 获得通过网络访问的Queue对象: 
  23. task = manager.get_task_queue() 
  24. result = manager.get_result_queue() 
  25. # 放几个任务进去: 
  26. for i in range(10): 
  27.  n = random.randint(0, 10000) 
  28.  print('Put task %d...' % n) 
  29.  task.put(n) 
  30. # 从result队列读取结果: 
  31. print('Try get results...'
  32. for i in range(10): 
  33.  r = result.get(timeout=10) 
  34.  print('Result: %s' % r) 
  35. # 关闭: 
  36. manager.shutdown() 
  37. print('master exit.'

请注意,当我们在一台机器上写多进程程序时,创建的Queue可以直接拿来用,但是,在分布式多进程环境下,添加任务到Queue不可以直接对原始的task_queue进行操作,那样就绕过了QueueManager的封装,必须通过manager.get_task_queue()获得的Queue接口添加。然后,在另一台机器上启动任务进程(本机上启动也可以)

写个task_worker.py

  1. #!/user/bin/pytthon 
  2. # -*- coding:utf-8 -*- 
  3. # @Time: 2018/3/3 16:46 
  4. # @Author: lichexo 
  5. # @File: task_worker.py 
  6. import time, sys, queue 
  7. from multiprocessing.managers import BaseManager 
  8. # 创建类似的QueueManager: 
  9. class QueueManager(BaseManager): 
  10.  pass 
  11. # 由于这个QueueManager只从网络上获取Queue,所以注册时只提供名字: 
  12. QueueManager.register('get_task_queue'
  13. QueueManager.register('get_result_queue'
  14. # 连接到服务器,也就是运行task_master.py的机器: 
  15. server_addr = '127.0.0.1' 
  16. print('Connect to server %s...' % server_addr) 
  17. # 端口和验证码注意保持与task_master.py设置的完全一致: 
  18. m = QueueManager(address=(server_addr, 5000), authkey=b'abc'
  19. # 从网络连接: 
  20. m.connect() 
  21. # 获取Queue的对象: 
  22. task = m.get_task_queue() 
  23. result = m.get_result_queue() 
  24. # 从task队列取任务,并把结果写入result队列: 
  25. for i in range(10): 
  26.  try: 
  27.  n = task.get(timeout=1) 
  28.  print('run task %d * %d...' % (n, n)) 
  29.  r = '%d * %d = %d' % (n, n, n*n) 
  30.  time.sleep(1) 
  31.  result.put(r) 
  32.  except Queue.Empty: 
  33.  print('task queue is empty.'
  34. # 处理结束: 
  35. print('worker exit.'

任务进程要通过网络连接到服务进程,所以要指定服务进程的IP。

运行结果

现在,可以试试分布式进程的工作效果了。先启动task_master.py服务进程:

  1. Traceback (most recent call last): 
  2.  File "F:/Python/untitled/xianchengjincheng/master.py", line 25, in <module> 
  3.  manager.start() 
  4.  File "F:Pythonpystalllibmultiprocessingmanagers.py", line 513, in start 
  5.  self._process.start() 
  6.  File "F:Pythonpystalllibmultiprocessingprocess.py", line 105, in start 
  7.  self._popen = self._Popen(self) 
  8.  File "F:Pythonpystalllibmultiprocessingcontext.py", line 322, in _Popen 
  9.  return Popen(process_obj) 
  10.  File "F:Pythonpystalllibmultiprocessingpopen_spawn_win32.py", line 65, in __init__ 
  11.  reduction.dump(process_obj, to_child) 
  12.  File "F:Pythonpystalllibmultiprocessing 
  13. eduction.py", line 60, in dump 
  14.  ForkingPickler(file, protocol).dump(obj) 
  15. _pickle.PicklingError: Can't pickle <function <lambda> at 0x00000202D1921E18>: attribute lookup <lambda> on __main__ failed 

task_master.py进程发送完任务后,开始等待result队列的结果。现在启动task_worker.py进程:

  1. Connect to server 127.0.0.1... 
  2. Traceback (most recent call last): 
  3.  File "F:/Python/untitled/xianchengjincheng/work.py", line 24, in <module> 
  4.  m.connect() 
  5.  File "F:Pythonpystalllibmultiprocessingmanagers.py", line 489, in connect 
  6.  conn = Client(self._address, authkey=self._authkey) 
  7.  File "F:Pythonpystalllibmultiprocessingconnection.py", line 487, in Client 
  8.  c = SocketClient(address) 
  9.  File "F:Pythonpystalllibmultiprocessingconnection.py", line 614, in SocketClient 
  10.  s.connect(address) 
  11. ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝,无法连接。 

看到没,结果都出错了,我们好好分析一下到底哪出错了。。。

错误分析

在task_master.py的报错提示中,我们知道它说lambda错误,这是因为序列化不支持匿名函数,所以我们得修改代码,重新对queue用QueueManager进行封装放到网络中。

  1. # 把两个Queue都注册到网络上, callable参数关联了Queue对象 
  2. QueueManager.register('get_task_queue',callable=return_task_queue)  
  3. QueueManager.register('get_result_queue',callable=return_result_queue) 

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

因为是分布式的环境,放入queue中的数据需要等待Workers机器运算处理后再进行读取,这样就需要对queue用QueueManager进行封装放到网络中,这是通过上面的2行代码来实现的。我们给return_task_queue的网络调用接口取了一个名get_task_queue,而return_result_queue的名字是get_result_queue,方便区分对哪个queue进行操作。task.put(n)即是对task_queue进行写入数据,相当于分配任务。而result.get()即是等待workers机器处理后返回的结果。

值得注意 在windows系统中你必须要写IP地址,而其他操作系统比如linux操作系统则就不要了。

  1. # windows需要写ip地址 
  2. manager = QueueManager(address=('127.0.0.1', 5000), authkey=b'abc'

修改后的代码

在task_master.py中修改如下:

  1. #!/user/bin/pytthon 
  2. # -*- coding:utf-8 -*- 
  3. # @Time: 2018/3/3 16:46 
  4. # @Author: lichexo 
  5. # @File: task_master.py 
  6. # task_master.py 
  7. import random,time,queue 
  8. from multiprocessing.managers import BaseManager 
  9. from multiprocessing import freeze_support 
  10. task_queue = queue.Queue() # 发送任务的队列: 
  11. result_queue = queue.Queue() # 接收结果的队列: 
  12. class QueueManager(BaseManager): # 从BaseManager继承的QueueManager: 
  13.  pass 
  14. # windows下运行 
  15. def return_task_queue(): 
  16.  global task_queue 
  17.  return task_queue # 返回发送任务队列 
  18. def return_result_queue (): 
  19.  global result_queue 
  20.  return result_queue # 返回接收结果队列 
  21. def test(): 
  22.  # 把两个Queue都注册到网络上, callable参数关联了Queue对象,它们用来进行进程间通信,交换对象 
  23.  #QueueManager.register('get_task_queue', callable=lambda: task_queue) 
  24.  #QueueManager.register('get_result_queue', callable=lambda: result_queue) 
  25.  QueueManager.register('get_task_queue', callable=return_task_queue) 
  26.  QueueManager.register('get_result_queue', callable=return_result_queue) 
  27.  # 绑定端口5000, 设置验证码'abc'
  28.  #manager = QueueManager(address=('', 5000), authkey=b'abc'
  29.  # windows需要写ip地址 
  30.  manager = QueueManager(address=('127.0.0.1', 5000), authkey=b'abc'
  31.  manager.start() # 启动Queue: 
  32.  # 获得通过网络访问的Queue对象: 
  33.  task = manager.get_task_queue() 
  34.  result = manager.get_result_queue() 
  35.  for i in range(10): # 放几个任务进去: 
  36.  n = random.randint(0, 10000) 
  37.  print('Put task %d...' % n) 
  38.  task.put(n) 
  39.  # 从result队列读取结果: 
  40.  print('Try get results...'
  41.  for i in range(10): 
  42.  # 这里加了异常捕获 
  43.  try: 
  44.  r = result.get(timeout=5) 
  45.  print('Result: %s' % r) 
  46.  except queue.Empty: 
  47.  print('result queue is empty.'
  48.  # 关闭: 
  49.  manager.shutdown() 
  50.  print('master exit.'
  51. if __name__=='__main__'
  52.  freeze_support() 
  53.  print('start!'
  54.  test() 

在task_worker.py中修改如下:

  1. #!/user/bin/pytthon 
  2. # -*- coding:utf-8 -*- 
  3. # @Time: 2018/3/3 16:46 
  4. # @Author: lichexo 
  5. # @File: task_worker.py 
  6. # task_worker.py 
  7. import time, sys, queue 
  8. from multiprocessing.managers import BaseManager 
  9. # 创建类似的QueueManager: 
  10. class QueueManager(BaseManager): 
  11.  pass 
  12. # 由于这个QueueManager只从网络上获取Queue,所以注册时只提供名字: 
  13. QueueManager.register('get_task_queue'
  14. QueueManager.register('get_result_queue'
  15. # 连接到服务器,也就是运行task_master.py的机器: 
  16. server_addr = '127.0.0.1' 
  17. print('Connect to server %s...' % server_addr) 
  18. # 端口和验证码注意保持与task_master.py设置的完全一致: 
  19. m = QueueManager(address=(server_addr, 5000), authkey=b'abc'
  20. # 从网络连接: 
  21. m.connect() 
  22. # 获取Queue的对象: 
  23. task = m.get_task_queue() 
  24. result = m.get_result_queue() 
  25. # 从task队列取任务,并把结果写入result队列: 
  26. for i in range(10): 
  27.  try: 
  28.  n = task.get(timeout=1) 
  29.  print('run task %d * %d...' % (n, n)) 
  30.  r = '%d * %d = %d' % (n, n, n*n) 
  31.  time.sleep(1) 
  32.  result.put(r) 
  33.  except queue.Empty: 
  34.  print('task queue is empty.'
  35. # 处理结束: 
  36. print('worker exit.'

先运行task_master.py,然后再运行task_worker.py

(1)task_master.py运行结果如下

  1. start! 
  2. Put task 7872... 
  3. Put task 6931... 
  4. Put task 1395... 
  5. Put task 8477... 
  6. Put task 8300... 
  7. Put task 1597... 
  8. Put task 8738... 
  9. Put task 8627... 
  10. Put task 1884... 
  11. Put task 2561... 
  12. Try get results... 
  13. Result: 7872 * 7872 = 61968384 
  14. Result: 6931 * 6931 = 48038761 
  15. Result: 1395 * 1395 = 1946025 
  16. Result: 8477 * 8477 = 71859529 
  17. Result: 8300 * 8300 = 68890000 
  18. Result: 1597 * 1597 = 2550409 
  19. Result: 8738 * 8738 = 76352644 
  20. Result: 8627 * 8627 = 74425129 
  21. Result: 1884 * 1884 = 3549456 
  22. Result: 2561 * 2561 = 6558721 
  23. master exit. 

(2)task_worker.py运行结果如下

  1. Connect to server 127.0.0.1... 
  2. run task 8640 * 8640... 
  3. run task 7418 * 7418... 
  4. run task 9303 * 9303... 
  5. run task 568 * 568... 
  6. run task 1633 * 1633... 
  7. run task 3583 * 3583... 
  8. run task 3293 * 3293... 
  9. run task 8975 * 8975... 
  10. run task 8189 * 8189... 
  11. run task 731 * 731... 
  12. worker exit. 

知识补充

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

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

 

Python分布式进程中你会遇到的坑

 

而Queue之所以能通过网络访问,就是通过QueueManager实现的。由于QueueManager管理的不止一个Queue,所以,要给每个Queue的网络调用接口起个名字,比如get_task_queue。task_worker这里的QueueManager注册的名字必须和task_manager中的一样。对比上面的例子,可以看出Queue对象从另一个进程通过网络传递了过来。只不过这里的传递和网络通信由QueueManager完成。

authkey有什么用?这是为了保证两台机器正常通信,不被其他机器恶意干扰。如果task_worker.py的authkey和task_master.py的authkey不一致,肯定连接不上。

责任编辑:武晓燕 来源: 今日头条
相关推荐

2018-06-28 08:18:56

Ceph运维存储

2022-05-18 10:38:51

Redis分布式锁数据

2019-08-08 09:57:53

分布式服务限流

2019-08-27 08:30:19

分布式服务限流

2022-07-06 08:01:05

数据库分布式

2022-08-12 18:40:00

分布式

2022-12-18 20:07:55

Redis分布式

2024-01-10 08:02:03

分布式技术令牌,

2019-06-19 15:40:06

分布式锁RedisJava

2022-11-14 07:23:32

RedisJedis分布式锁

2021-03-24 08:41:38

Redis 分布式锁序列化

2018-12-14 10:06:22

缓存分布式系统

2019-11-19 08:47:45

Zookeeper分布式事务

2023-02-20 15:38:38

2022-09-13 09:14:48

架构系统

2022-03-21 19:44:30

CitusPostgreSQ执行器

2016-11-02 12:06:27

分布式系统大数据

2022-01-26 13:46:40

分布式事务集合,这

2024-10-18 08:00:00

分布式系统背压数据库

2021-09-26 09:16:45

RedisGeo 类型数据类型
点赞
收藏

51CTO技术栈公众号