安装第三方库

pip install psutil

使用如下,假设进程号为3213

import psutil

proc = psutil.Process(pid=3213)

print proce.name()

基于官方文档：

https://docs.python.org/zh-cn/3/library/multiprocessing.html

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

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

通常我们使用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() 获得）

报错：

参考 ： https://blog.csdn.net/xiemanR/article/details/71700531

把 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 挂了:

参考： https://blog.csdn.net/hedongho/article/details/79139606

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

关于map 传多个函数参数

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

报错：

参考：

https://blog.csdn.net/qq_15969343/article/details/84672527

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

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

最简单的方法：

使用 starmap 而不是 map

结果：

子进程结束

1.8399453163146973

成功拿到结果了

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

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

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

itertools 用法参考：

https://docs.python.org/zh-cn/3/library/itertools.html#itertool-functions

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

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

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

解决：

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

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

使用 queue.empty() 空为True

想要充分利用多核CPU资源，Python中大部分情况下都需要使用多进程，Python中提供了multiprocessing这个包实现多进程。multiprocessing支持子进程、进程间的同步与通信，提供了Process、Queue、Pipe、Lock等组件。

开辟子进程

multiprocessing中提供了Process类来生成进程实例

Process([group [, target [, name [, args [, kwargs]]]]])

group分组，实际上不使用

target表示调用对象，你可以传入方法的名字

args表示给调用对象以元组的形式提供参数，比如target是函数a，他有两个参数m，n，那么该参数为args=(m, n)即可

kwargs表示调用对象的字典

name是别名，相当于给这个进程取一个名字

先来个小例子：

# -*- coding:utf-8 -*-

from multiprocessing import Process, Pool

import os

import time

def run_proc(wTime):

n = 0

while n <3:

print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())#获取当前进程号和正在运行是的时间

time.sleep(wTime)#等待（休眠）

n += 1

if __name__ == "__main__":

p = Process(target=run_proc, args=(2,)) #申请子进程

p.start() #运行进程

print "Parent process run. subProcess is ", p.pid

print "Parent process end,{0}".format(time.ctime())

运行结果：

Parent process run. subProcess is 30196

Parent process end,Mon Mar 27 11:20:21 2017

subProcess 30196 run, Mon Mar 27 11:20:21 2017

subProcess 30196 run, Mon Mar 27 11:20:23 2017

subProcess 30196 run, Mon Mar 27 11:20:25 2017

根据运行结果可知，父进程运行结束后子进程仍然还在运行，这可能造成僵尸（ zombie）进程。

通常情况下，当子进程终结时，它会通知父进程，清空自己所占据的内存，并在内核里留下自己的退出信息。父进程在得知子进程终结时，会从内核中取出子进程的退出信息。但是，如果父进程早于子进程终结，这可能造成子进程的退出信息滞留在内核中，子进程成为僵尸（zombie）进程。当大量僵尸进程积累时，内存空间会被挤占。

有什么办法可以避免僵尸进程呢？

这里介绍进程的一个属性 deamon，当其值为TRUE时，其父进程结束，该进程也直接终止运行（即使还没运行完）。

所以给上面的程序加上p.deamon = true，看看效果。

# -*- coding:utf-8 -*-

from multiprocessing import Process, Pool

import os

import time

def run_proc(wTime):

n = 0

while n <3:

print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())

time.sleep(wTime)

n += 1

if __name__ == "__main__":

p = Process(target=run_proc, args=(2,))

p.daemon = True#加入daemon

p.start()

print "Parent process run. subProcess is ", p.pid

print "Parent process end,{0}".format(time.ctime())

执行结果：

Parent process run. subProcess is 31856

Parent process end,Mon Mar 27 11:40:10 2017

这是问题又来了，子进程并没有执行完，这不是所期望的结果。有没办法将子进程执行完后才让父进程结束呢？

这里引入p.join()方法，它使子进程执行结束后，父进程才执行之后的代码

# -*- coding:utf-8 -*-

from multiprocessing import Process, Pool

import os

import time

def run_proc(wTime):

n = 0

while n <3:

print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())

time.sleep(wTime)

n += 1

if __name__ == "__main__":

p = Process(target=run_proc, args=(2,))

p.daemon = True

p.start()

p.join()#加入join方法

print "Parent process run. subProcess is ", p.pid

print "Parent process end,{0}".format(time.ctime())

执行结果：

subProcess 32076 run, Mon Mar 27 11:46:07 2017

subProcess 32076 run, Mon Mar 27 11:46:09 2017

subProcess 32076 run, Mon Mar 27 11:46:11 2017

Parent process run. subProcess is 32076

Parent process end,Mon Mar 27 11:46:13 2017

这样所有的进程就能顺利的执行了。

---