Python multiprocessing多进程原理与应用示例

更新时间：2019年02月28日 14:30:17 作者：-牧野-

这篇文章主要介绍了Python multiprocessing多进程原理与应用,结合实例形式详细分析了基于multiprocessing包的多进程概念、原理及相关使用操作技巧,需要的朋友可以参考下

本文实例讲述了Python multiprocessing多进程原理与应用。分享给大家供大家参考，具体如下：

multiprocessing包是Python中的多进程管理包,可以利用multiprocessing.Process对象来创建进程,Process对象拥有is_alive()、join([timeout])、run()、start()、terminate()等方法。

multprocessing模块的核心就是使管理进程像管理线程一样方便，每个进程有自己独立的GIL，所以不存在进程间争抢GIL的问题，在多核CPU环境中，可以大大提高运行效率。

multiprocessing使用示例：

import multiprocessing
import time
import cv2
def daemon1(image):
  name = multiprocessing.current_process().name
  for i in range(50):
    image = cv2.GaussianBlur(image, (3, 3), 1)
    time.sleep(0.1)
  print 'daemon1 done!'
  cv2.imshow('daemon1', image)
def daemon2(image):
  name = multiprocessing.current_process().name
  for i in range(50):
    image = cv2.GaussianBlur(image, (3, 3), 1)
    time.sleep(0.5)
  print 'daemon2 done!'
  cv2.imshow('daemon2', image)
if __name__ == '__main__':
  t1 = time.time()
  number_kernel = multiprocessing.cpu_count()
  print 'We have {0} kernels'.format(number_kernel)
  p1 = multiprocessing.Process(name='daemon1',
                target=daemon1,args= (cv2.imread('./p1.jpg'),))
  p1.daemon = False
  p2 = multiprocessing.Process(name='daemon2',
                target=daemon2, args=(cv2.imread('./p2.jpg'),))
  p2.daemon = False
  p1.start()
  p2.start()
  print 'p1 is {0}'.format(p1.is_alive())
  p1.terminate()
  p1.join()
  print 'p1 is {0}'.format(p1.is_alive())
  print 'p2 is {0}'.format(p2.is_alive())
  p2.join()
  t2 = time.time()
  print '!!!!!!!!!!!!!!!!!!!!OK!!!!!!!!!!!!!!!!!!!!!'
  print 'total time is {0}'.format(t2-t1)
  print 'p1.exitcode = {0}'.format(p1.exitcode)
  print 'p2.exitcode = {0}'.format(p2.exitcode)

multiprocessing中Process是一个类，用于创建进程，以及定义进程的方法，Process类的构造函数是：

def __init__(self, group=None, target=None, name=None, args=(), kwargs={})

参数含义：

group：进程所属组，基本不用
target：创建进程关联的对象，需要传入要多进程处理的函数名
name：定义进程的名称
args：表示与target相关联的函数的传入参数，可以传入多个，注意args是一个元组，如果传入的参数只有一个，需要表示为 args = (element1,)
kwargs：表示调用对象的字典

程序解读：

multiprocessing.cpu_count()：返回机器上cpu核的总数量
p1.daemon = False ：定义子进程的运行属性，如果 .daemon设置为False表示子进程可以在主进程完成之后继续执行；如果 .daemon设置为True，表示子进程随着主进程的结束而结束；必须在start之前设置；
p1.start(): 开始执行子进程p1
p1.join(): 定义子进程p1的运行阻塞主进程，只有p1子进程执行完成之后才会继续执行join之后的主进程，但是子进程间互相不受join影响。
可以定义子进程阻塞主进程的时间--p1.join(100)，超时之后，主进程不再等待，开始执行。join()需要放在start()方法之后；
p1.terminate()：终止子进程的执行，其后要跟上jion()方法更新子进程的状态；
p1.exitcode：进程的退出状态： == 0 未生成任何错误，正常退出； > 0 进程有一个错误，并以该错误码退出； <0 进程由一个-1 * exitcode信号结束

在multiprocessing中使用pool

如果需要多个子进程时，使用进程池(pool)来（自动）管理各个子进程更加方便：

from multiprocessing import Pool
import os, time
def long_time_task(name):
  print 'Run task {0} ({1})'.format(name,os.getpid())
  start = time.time()
  time.sleep(3)
  end = time.time()
  print 'Task {0} runs {1:.2f} seconds.'.format(name,end - start)
if __name__=='__main__':
  print 'Parent process ({0})'.format(os.getpid)
  p = Pool()
  for i in range(12):
    p.apply_async(long_time_task, args=(i,))
  print 'Waiting for all subprocesses done...'
  p.close()
  p.join()
  print 'All subprocesses done.'

与Process类创建进程的方法不同，Pool是通过apply_async(func,args=(args))方法创建进程，一个进程池中能同时运行的任务数是机器上CPU核的总数量n_kernel，如果创建的子进程数大于n_kernel，则同时执行n_kernel个进程，这n_kernel中某个进程完成之后才会启动下一个进程。

os.getpid()是获取当前执行的进程的ID
p.close()方法是关掉进程池，表示不能再继续向进程池添加进程了。
p.join()方法是子进程阻塞主进程，必须在调用p.close()关闭进程池之后才能调用join()方法

多个子进程间的通信

多个子进程间的通信要用到multiprocessing.Queue，Queue的特性是它是一个消息队列。比如有以下的需求，一个子进程向队列中写数据，另外一个进程从队列中取数据的例子：

from multiprocessing import Process, Queue
import os, time, random
def write(q):
  for value in ['A', 'B', 'C']:
    print 'Put {0} to queue...'.format(value)
    q.put(value)
    time.sleep(random.random())
def read(q):
  while True:
    if not q.empty():
      value = q.get(True)
      print 'Get {0} from queue.'.format(value)
      time.sleep(random.random())
    else:
      break
if __name__=='__main__':
  q = multiprocessing.Queue()
  pw = Process(target=write, args=(q,))
  pr = Process(target=read, args=(q,))
  pw.start()
  pw.join()
  pr.start()
  pr.join()

Queue使用方法：

Queue.qsize()：返回当前队列包含的消息数量；
Queue.empty()：如果队列为空，返回True，反之False ；
Queue.full()：如果队列满了，返回True,反之False；
Queue.get():获取队列中的一条消息，然后将其从列队中移除，可传参超时时长；
Queue.get_nowait()：相当Queue.get(False),取不到值时触发异常：Empty；
Queue.put():将一个值添加进数列，可传参超时时长；
Queue.put_nowait():相当于Queue.get(False),当队列满了时报错：Full；

在进程池Pool中，使用Queue会出错，需要使用Manager.Queue：

from multiprocessing import Process, Queue
import os, time, random
def write(q):
  for value in ['A', 'B', 'C']:
    print 'Put {0} to queue...'.format(value)
    q.put(value)
    time.sleep(random.random())
def read(q):
  while True:
    if not q.empty():
      value = q.get(True)
      print 'Get {0} from queue.'.format(value)
      time.sleep(random.random())
    else:
      break
if __name__=='__main__':
  manager = multiprocessing.Manager()
  q = manager.Queue()
  p = Pool()
  pw = p.apply_async(write, args=(q,))
  time.sleep(2)
  pr = p.apply_async(read, args=(q,))
  p.close()
  p.join()
  if not q.empty():
    print 'q is not empty...'
  else:
    print 'q is empty...'
  print 'OK'
  if not q.empty():
    print 'q is not empty...'
  else:
    print 'q is empty...'
  print 'done...'

父进程与子进程共享内存

定义普通的变量，不能实现在父进程和子进程之间共享：

import multiprocessing
from multiprocessing import Pool
def changevalue(n, a):
  n = 3.14
  a[0] = 5
if __name__ == '__main__':
  num = 0
  arr = range(10)
  p = Pool()
  p1 = p.apply_async(changevalue, args=(num, arr))
  p.close()
  p.join()
  print num
  print arr[:]

结果输出num的值还是在父进程中定义的0，arr的第一个元素值还是0。

使用multiprocessing创建共享对象:

import multiprocessing
def changevalue(n, a):
  n.value = 3.14
  a[0] = 5
if __name__ == '__main__':
  num = multiprocessing.Value('d', 0.0)
  arr = multiprocessing.Array('i', range(10))
  p = multiprocessing.Process(target=changevalue, args=(num, arr))
  p.start()
  p.join()
  print num.value
  print arr[:]

结果输出num的值是在子进程中修改的3.14，arr的第一个元素值更改为5。

共享内存在Pool中的使用：

import multiprocessing
from multiprocessing import Pool
def changevalue(n, a):
  n.value = 3.14
  a[0] = 5
if __name__ == '__main__':
  num = multiprocessing.Value('d', 0.0)
  arr = multiprocessing.Array('i', range(10))
  p = Pool()
  p1 = p.apply_async(changevalue, args=(num, arr))
  p.close()
  p.join()
  print num.value
  print arr[:]

更多关于Python相关内容感兴趣的读者可查看本站专题：《Python进程与线程操作技巧总结》、《Python数据结构与算法教程》、《Python函数使用技巧总结》、《Python字符串操作技巧汇总》、《Python入门与进阶经典教程》、《Python+MySQL数据库程序设计入门教程》及《Python常见数据库操作技巧汇总》

希望本文所述对大家Python程序设计有所帮助。

您可能感兴趣的文章:

Python文件监听工具pyinotify与watchdog实例
今天小编就为大家分享一篇关于Python文件监听工具pyinotify与watchdog实例，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
2018-10-10
python用pyecharts画地图实例介绍
大家好，本篇文章主要讲的是python用pyecharts画地图实例介绍，感兴趣的同学赶快来看一看吧，对你有帮助的话记得收藏一下
2022-02-02
Python3生成手写体数字方法
本篇文章给大家分享习如何Python3生成手写体数字方法以及实例代码分享，有兴趣的朋友参考下吧。
2018-01-01
深入浅析Python代码规范性检测
这篇文章主要介绍了Python代码规范性检测,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2020-07-07
python中的位置参数和关键字参数详解
位置参数和关键字参数是 Python 中的两种不同类型的函数参数传递方式,位置参数依赖于参数的位置顺序,而关键字参数通过参数名传递,不受位置影响,本文通过代码示例给大家详细介绍了python中的位置参数和关键字参数,需要的朋友可以参考下
2023-12-12
Python文件右键找不到IDLE打开项解决办法
这篇文章主要介绍了Python文件右键找不到IDLE打开项解决办法,本文使用注册表解决了这个问题,需要的朋友可以参考下
2015-06-06
Python实现绘制置信区间
置信区间是从观测数据的统计量计算的一种估计值,它给出了一个可能包含具有特定置信水平的总体参数的值范围,下面我们就来看看如何使用Python绘制置信区间吧
2024-02-02
利用Python绘制创意中秋节月饼
又是一年中秋至——花好月圆夜。turtle库作为Python重要的标准库之一，是最有价值的程序设计入门实践库,它是程序设计入门层面最常用的基本绘图库。本文将使用turtle（海龟）来绘制中秋创意月饼，感兴趣的可以了解一下
2022-09-09
Python使用线程来接收串口数据的示例
今天小编就为大家分享一篇Python使用线程来接收串口数据的示例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2019-07-07
python脚本当作Linux中的服务启动实现方法
今天小编就为大家分享一篇python脚本当作Linux中的服务启动实现方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2019-06-06

Python multiprocessing多进程原理与应用示例

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具