Python多进程multiprocessing模块介绍

multiprocessing 是一个支持使用与 threading 模块类似的 API 来产生进程的包。 multiprocessing 包同时提供了本地和远程并发操作，通过使用子进程而非线程有效地绕过了 全局解释器锁。 因此，multiprocessing 模块允许程序员充分利用给定机器上的多个处理器。 它在 Unix 和 Windows 上均可运行。

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：空间域名、网页空间、营销软件、网站建设、古丈网站维护、网站推广。

1、multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

2、相关方法

输出结果如下：

Pool提供了一种快捷的方法，赋予函数并行化处理一系列输入值的能力，可以将输入数据分配给不同进程处理（数据并行）。下面的例子演示了在模块中定义此类函数的常见做法，以便子进程可以成功导入该模块。这个数据并行的基本例子使用了 Pool 。

将在标准输出中打印

其中：

（1）p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func( args, kwargs),然后返回结果。需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，必须从不同线程调用p.apply()函数或者使用p.apply_async()

（2）p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func( args,**kwargs),然后返回结果。此方法的结果是 AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。多进程并发！

（3）p.close():关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成

（4）p.jion():等待所有工作进程退出。此方法只能在close（）或teminate()之后调用

如何使用Python实现多进程编程

1. Process

创建进程的类：Process([group [, target [, name [, args [, kwargs]]]]])，target表示调用对象，args表示调用对象的位置参数元组。kwargs表示调用对象的字典。name为别名。group实质上不使用。

方法：is_alive()、join([timeout])、run()、start()、terminate()。其中，Process以start()启动某个进程。

属性：authkey、daemon（要通过start()设置）、exitcode(进程在运行时为None、如果为–N，表示被信号N结束）、name、pid。其中daemon是父进程终止后自动终止，且自己不能产生新进程，必须在start()之前设置。

例1.1：创建函数并将其作为单个进程

import multiprocessing

import time

def worker(interval):

n = 5

while n  0:

print("The time is {0}".format(time.ctime()))

time.sleep(interval)

n -= 1

if __name__ == "__main__":

p = multiprocessing.Process(target = worker, args = (3,))

p.start()

print "p.pid:", p.pid

print "p.name:", p.name

print "p.is_alive:", p.is_alive()

结果

12345678    p.pid: 8736p.name: Process-1p.is_alive: TrueThe time is Tue Apr 21 20:55:12 2015The time is Tue Apr 21 20:55:15 2015The time is Tue Apr 21 20:55:18 2015The time is Tue Apr 21 20:55:21 2015The time is Tue Apr 21 20:55:24 2015    

例1.2：创建函数并将其作为多个进程

import multiprocessing

import time

def worker_1(interval):

print "worker_1"

time.sleep(interval)

print "end worker_1"

def worker_2(interval):

print "worker_2"

time.sleep(interval)

print "end worker_2"

def worker_3(interval):

print "worker_3"

time.sleep(interval)

print "end worker_3"

if __name__ == "__main__":

p1 = multiprocessing.Process(target = worker_1, args = (2,))

p2 = multiprocessing.Process(target = worker_2, args = (3,))

p3 = multiprocessing.Process(target = worker_3, args = (4,))

p1.start()

p2.start()

p3.start()

print("The number of CPU is:" + str(multiprocessing.cpu_count()))

for p in multiprocessing.active_children():

print("child   p.name:" + p.name + "\tp.id" + str(p.pid))

print "END!!!!!!!!!!!!!!!!!"

结果

1234567891011    The number of CPU is:4child   p.name:Process-3    p.id7992child   p.name:Process-2    p.id4204child   p.name:Process-1    p.id6380END!!!!!!!!!!!!!!!!!worker_1worker_3worker_2end worker_1end worker_2end worker_3    

例1.3：将进程定义为类

import multiprocessing

import time

class ClockProcess(multiprocessing.Process):

def __init__(self, interval):

multiprocessing.Process.__init__(self)

self.interval = interval

def run(self):

n = 5

while n  0:

print("the time is {0}".format(time.ctime()))

time.sleep(self.interval)

n -= 1

if __name__ == '__main__':

p = ClockProcess(3)

p.start()      

注：进程p调用start()时，自动调用run()

结果

12345    the time is Tue Apr 21 20:31:30 2015the time is Tue Apr 21 20:31:33 2015the time is Tue Apr 21 20:31:36 2015the time is Tue Apr 21 20:31:39 2015the time is Tue Apr 21 20:31:42 2015

python 多进程

基于官方文档：

日乐购，刚才看到的一个博客，写的都不太对，还是基于官方的比较稳妥

我就是喜欢抄官方的，哈哈

通常我们使用Process实例化一个进程，并调用 他的 start() 方法启动它。

这种方法和 Thread 是一样的。

上图中，我写了 p.join() 所以主进程是 等待 子进程执行完后，才执行 print("运行结束")

否则就是反过来了（这个不一定，看你的语句了，顺序其实是随机的）例如：

主进加个 sleep

所以不加join() ,其实子进程和主进程是各干各的，谁也不等谁。都执行完后，文件运行就结束了

上面我们用了 os.getpid() 和 os.getppid() 获取 当前进程，和父进程的id

下面就讲一下，这两个函数的用法：

os.getpid()

返回当前进程的id

os.getppid()

返回父进程的id。 父进程退出后，unix 返回初始化进程（1）中的一个

windows返回相同的id (可能被其他进程使用了)

这也就解释了，为啥我上面 的程序运行多次， 第一次打印的parentid 都是 14212 了。

而子进程的父级 process id 是调用他的那个进程的 id ： 1940

视频笔记：

多进程：使用大致方法：

参考： 进程通信（pipe和queue）

pool.map （函数可以有return 也可以共享内存或queue） 结果直接是个列表

poll.apply_async() （同map,只不过是一个进程，返回结果用 xx.get() 获得）

报错：

参考 ：

把 pool = Pool() 放到 if name == " main ": 下面初始化搞定。

结果：

这个肯定有解释的

测试多进程计算效果：

进程池运行：

结果：

普通计算：

我们同样传入 1 2 10 三个参数测试：

其实对比下来开始快了一半的；

我们把循环里的数字去掉一个 0；

单进程：

多进程：

两次测试 单进程/进程池 分别为 0.669 和 0.772 几乎成正比的。

问题 二：

视图：

post 视图里面

Music 类：

直接报错：

写在 类里面也 在函数里用 self.pool 调用也不行，也是相同的错误。

最后 把 pool = Pool 直接写在 search 函数里面，奇迹出现了：

前台也能显示搜索的音乐结果了

总结一点，进程这个东西，最好 写在 直接运行的函数里面，而不是 一个函数跳来跳去。因为最后可能 是在子进程的子进程运行的，这是不许的，会报错。

还有一点，多进程运行的函数对象，不能是 lambda 函数。也许lambda 虚拟，在内存？？

使用 pool.map 子进程 函数报错，导致整个 pool 挂了:

参考：

主要你要，对函数内部捕获错误，而不能让异常抛出就可以了。

关于map 传多个函数参数

我一开始，就是正常思维，多个参数，搞个元祖，让参数一一对应不就行了：

报错：

参考：

普通的 process 当让可以穿多个参数，map 却不知道咋传的。

apply_async 和map 一样，不知道咋传的。

最简单的方法：

使用 starmap 而不是 map

结果：

子进程结束

1.8399453163146973

成功拿到结果了

关于map 和 starmap 不同的地方看源码：

关于apply_async() ,我没找到多参数的方法，大不了用 一个迭代的 starmap 实现。哈哈

关于 上面源码里面有 itertools.starmap

itertools 用法参考：

有个问题，多进程最好不要使用全部的 cpu , 因为这样可能影响其他任务，所以 在进程池 添加 process 参数 指定，cpu 个数：

上面就是预留了 一个cpu 干其他事的

后面直接使用 Queue 遇到这个问题：

解决：

Manager().Queue() 代替 Queue()

因为 queue.get() 是堵塞型的，所以可以提前判断是不是 空的，以免堵塞进程。比如下面这样：

使用 queue.empty() 空为True