1. 多任务的概念
2. 进程的创建-multiprocessing.Process
3. 进程的创建-Process子类
4. 进程池-Pool
5. 进程间通信-Queue
1. 多任务的概念
现在，多核CPU已经非常普及了，但是，即使过去的单核CPU，也可以执行多任务。由于CPU执行代码都是顺序执行的，那么，单核CPU是怎么执行多任务的呢？
答案就是操作系统轮流让各个任务交替执行，任务1执行0.01秒，切换到任务2，任务2执行0.01秒，再切换到任务3，执行0.01秒……这样反复执行下去。表面上看，每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。
真正的并行执行多任务只能在多核CPU上实现，但是，由于任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。
进程 VS 程序
- 程序：编写完毕的代码，在没有运行的时候，称之为程序。
- 进程：正在运行着的代码，就成为进程。
进程除了包含代码以外，还有需要运行的环境等，所以和程序是有区别的。
多进程中，每个进程中所有数据（包括全局变量）都各有拥有一份，互不影响。
2. 进程的创建-multiprocessing.Process
multiprocessing模块是跨平台版本的多进程模块。
multiprocessing模块提供了一个Process类来代表一个进程对象，下面的例子演示了启动一个子进程并等待其结束：
1 from multiprocessing import Process
2 import os
3
4
5 # 子进程要执行的代码
6 def run_proc(name):
7 print("子进程{}运行中，pid={}；父进程：ppid={}".format(name, os.getpid(), os.getppid()))
8
9 if __name__=="__main__":
10 print("父进程：{}".format(os.getpid()))
11 p = Process(target=run_proc, args=("test",))
12 print("子进程将要执行")
13 p.start() # 让子进程开始执行run_proc函数的代码，函数执行完后即子进程也结束
14 p.join() # 堵塞：等待该子进程执行完后，才会继续往下执行
15 print("子进程已结束")
16
17 # 主进程等Process创建的所有子进程执行完后，才会结束
执行结果：
父进程：1420 子进程将要执行 子进程test运行中，pid=6080；父进程：ppid=1420 子进程已结束
Process([group [, target [, name [, args [, kwargs]]]]]) 类
- target：表示这个进程实例所调用对象
- args：表示调用对象的位置参数元组
- kwargs：表示调用对象的关键字参数字典
- name：为当前进程实例的别名
- group：大多数情况下用不到
Process类常用方法
- is_alive()：判断进程实例是否还在执行
- join([timeout])：是否等待进程实例执行结束，或等待多少秒
- start()：启动进程实例（创建子进程）
- run()：如果没有给定target参数，对这个对象调用start()方法时，就将执行对象中的run()方法
- terminate()：不管任务是否完成，立即终止
Process类常用属性
- name：当前进程实例别名，默认为Process-N，N为从1开始递增的整数
- pid：当前进程实例的PID值
示例：传入字典
1 from multiprocessing import Process
2 import os
3 import time
4
5
6 # 子进程要执行的代码
7 def run_proc(name, age, **kwargs):
8 # 让子进程执行足够多的时间
9 for i in range(10):
10 print("子进程运行中：name={}, age={}, pid={}".format(name, age, os.getpid()))
11 print(kwargs)
12
13 if __name__=="__main__":
14 print("父进程：{}".format(os.getpid()))
15 p = Process(target=run_proc, args=("test", 18), kwargs={"m":20})
16 print("子进程将要执行")
17 p.start()
18 time.sleep(0.2)
19 p.terminate()
20 p.join
21 print("子进程已结束")
执行结果：
父进程：2636
子进程将要执行
子进程运行中：name=test, age=18, pid=11560
{'m': 20}
子进程运行中：name=test, age=18, pid=11560
{'m': 20}
子进程运行中：name=test, age=18, pid=11560
{'m': 20}
子进程已结束
示例：两个子进程
1 from multiprocessing import Process
2 import time
3 import os
4
5
6 def worker_1(interval):
7 print("worker_1，父进程：{}，当前进程：{}".format(os.getppid(), os.getpid()))
8 t_start = time.time()
9 time.sleep(interval)
10 t_end = time.time()
11 print("worker_1 整体执行时间为%.2f秒" % (t_end - t_start))
12
13
14 def worker_2(interval):
15 print("worker_2，父进程：{}，当前进程：{}".format(os.getppid(), os.getpid()))
16 t_start = time.time()
17 time.sleep(interval)
18 t_end = time.time()
19 print("worker_2 整体执行时间为%.2f秒" % (t_end - t_start))
20
21 if __name__ == "__main__":
22
23 # 输出当前主进程的id
24 print("进程ID：{}".format(os.getpid()))
25
26 p1 = Process(target=worker_1, args=(2,))
27 p2 = Process(target=worker_2, name="worker2", args=(1,))
28
29 p1.start()
30 p2.start()
31
32 # 同时主进程仍在往下执行，如果p2进程还在执行，返回True
33 print("p2 is alive = {}".format(p2.is_alive()))
34
35 # 输出p1和p2进程的别名和pid
36 print("p1.name=%s" % p1.name)
37 print("p1.pid=%s" % p1.pid)
38 print("p2.name=%s" % p2.name)
39 print("p2.pid=%s" % p2.pid)
40
41 p1.join()
42 print("p1.is_alive=%s" % p1.is_alive())
执行结果：
进程ID：6572 p2 is alive = True p1.name=Process-1 p1.pid=4716 p2.name=worker2 p2.pid=14936 worker_1，父进程：6572，当前进程：4716 worker_2，父进程：6572，当前进程：14936 worker_2 整体执行时间为1.02秒 worker_1 整体执行时间为2.02秒 p1.is_alive=False
注意：若以上执行代码未在 if __name__ == "__main__:" 中，会出现RuntimeError，错误提示如下：
An attempt has been made to start a new process before the current process has finished its bootstrapping phase.
This probably means that you are not using fork to start your child processes and you have forgotten to use the
proper idiom in the main module:
if __name__ == '__main__':
freeze_support()
...
The "freeze\_support()" line can be omitted if the program is not going to be frozen to produce an executable.
简单解释
由于Python运行过程中，新创建进程后，进程会导入正在运行的文件，即代码在运行到Process()时，新的进程会重新读入该代码，对于没有 if __name__=="__main__" 保护的代码，新进程都认为是要再次运行的代码，这时子进程又一次运行Process()，但是在multiprocessing.Process的源码中是对子进程再次产生子进程是做了限制的，是不允许的，于是出现如上的错误提示。
3. 进程的创建-Process子类
创建新的进程还能够使用类的方式，可以自定义一个类，继承Process类，每次实例化这个类的时候，就等同于实例化一个进程对象。
示例：
1 from multiprocessing import Process
2 import time
3 import os
4
5
6 class ProcessClass(Process):
7
8 def __init__(self, interval):
9 Process.__init__(self)
10 self.interval = interval
11
12 def run(self):
13 print("子进程(%d)开始执行，父进程为%d" % (os.getpid(), os.getppid()))
14 t_start = time.time()
15 time.sleep(self.interval)
16 t_end = time.time()
17 print("子进程(%d)执行结束，执行时间为%.2f秒" % (os.getpid(), t_end-t_start))
18
19
20 if __name__ == "__main__":
21 print("当前主进程(%d)" % os.getpid())
22 t_start = time.time()
23 p = ProcessClass(1)
24 # 对一个不包含target属性的Process类执行start()方法，就会运行这个类中的run()方法，所以这里会执行p1.run()
25 p.start()
26 p.join()
27 t_end = time.time()
28 print("当前主进程(%d)执行结束，执行时间为%.2f秒"%(os.getpid(), t_end-t_start))
执行结果：
当前主进程(764) 子进程(10256)开始执行，父进程为764 子进程(10256)执行结束，执行时间为1.02秒 当前主进程(764)执行结束，执行时间为1.37秒
4. 进程池-Pool
当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。
初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来执行。
示例：
1 from multiprocessing import Pool
2 import os
3 import time
4 import random
5
6
7 # 定义子进程函数
8 def worker(msg):
9 t_start = time.time()
10 print("进程(%s)开始执行，id=%d" % (msg, os.getpid()))
11 # random.random()：随机生成0~1之间的浮点数
12 time.sleep(random.random()*2)
13 t_end = time.time()
14 print("进程(%s)执行完毕，耗时%.2f秒" % (msg, t_end-t_start))
15
16
17 if __name__ == "__main__":
18 # 创建一个进程池，最大进程数为3
19 po = Pool(3)
20 # 每次循环将会用空闲出来的子进程去调用目标函数
21 for i in range(10):
22 # apply_async(要调用的目标函数, (传递给函数的参数元组,))
23 po.apply_async(worker, (i,))
24
25 print("------start------")
26 po.close() # 关闭进程池，关闭后po不再接收新的请求
27 po.join() # 等到po中所有子进程执行完成。必须放在close语句之后
28 print("-------end-------")
执行结果：
------start------ 进程(0)开始执行，id=4276 进程(1)开始执行，id=12064 进程(2)开始执行，id=5444 进程(0)执行完毕，耗时0.39秒 进程(3)开始执行，id=4276 进程(3)执行完毕，耗时0.47秒 进程(4)开始执行，id=4276 进程(2)执行完毕，耗时1.05秒 进程(5)开始执行，id=5444 进程(1)执行完毕，耗时1.41秒 进程(6)开始执行，id=12064 进程(6)执行完毕，耗时0.06秒 进程(7)开始执行，id=12064 进程(4)执行完毕，耗时0.66秒 进程(8)开始执行，id=4276 进程(5)执行完毕，耗时0.56秒 进程(9)开始执行，id=5444 进程(7)执行完毕，耗时0.19秒 进程(8)执行完毕，耗时0.80秒 进程(9)执行完毕，耗时1.05秒 -------end-------
multiprocessing.Pool 常用函数解析：
- apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给func的关键字参数列表。
- apply(func[, args[, kwds]])：使用阻塞方式调用func。
- close()：关闭Pool，使其不再接受新的任务。
- terminate()：不管任务是否完成，立即终止。
- join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用。
示例：apply 堵塞型
1 from multiprocessing import Pool
2 import os
3 import time
4 import random
5
6
7 # 定义子进程函数
8 def worker(msg):
9 t_start = time.time()
10 print("进程(%s)开始执行，id=%d" % (msg, os.getpid()))
11 # random.random()：随机生成0~1之间的浮点数
12 time.sleep(random.random()*2)
13 t_end = time.time()
14 print("进程(%s)执行完毕，耗时%.2f秒" % (msg, t_end-t_start))
15
16
17 if __name__ == "__main__":
18 # 创建一个进程池，最大进程数为3
19 po = Pool(3)
20 # 每次循环将会用空闲出来的子进程去调用目标函数
21 for i in range(10):
22 po.apply(worker, (i,))
23
24 print("------start------")
25 po.close() # 关闭进程池，关闭后po不再接收新的请求
26 po.join() # 等到po中所有子进程执行完成。必须放在close语句之后
27 print("-------end-------")
执行结果：
进程(0)开始执行，id=3260 进程(0)执行完毕，耗时1.67秒 进程(1)开始执行，id=8788 进程(1)执行完毕，耗时0.58秒 进程(2)开始执行，id=14492 进程(2)执行完毕，耗时1.67秒 进程(3)开始执行，id=3260 进程(3)执行完毕，耗时1.12秒 进程(4)开始执行，id=8788 进程(4)执行完毕，耗时1.48秒 进程(5)开始执行，id=14492 进程(5)执行完毕，耗时1.55秒 进程(6)开始执行，id=3260 进程(6)执行完毕，耗时0.08秒 进程(7)开始执行，id=8788 进程(7)执行完毕，耗时0.06秒 进程(8)开始执行，id=14492 进程(8)执行完毕，耗时1.41秒 进程(9)开始执行，id=3260 进程(9)执行完毕，耗时1.72秒 ------start------ -------end-------
5. 进程间通信-Queue
Process之间有时需要通信，操作系统提供了很多机制来实现进程间的通信。
Queue的使用
可以使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序。
Queue()对象
- 初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）。
- Queue.qsize()：返回当前队列包含的消息数量。
- Queue.empty()：如果队列为空，返回True，反之False。
- Queue.full()：如果队列满了，返回True，反之False。
- Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True。
- 如果block使用默认值True，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常。
- 如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常。
- Queue.get_nowait()：相当Queue.get(False)。
- Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True。
- 如果block使用默认值True，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出"Queue.Full"异常。
- 如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常。
- Queue.put_nowait(item)：相当Queue.put(item, False)。
示例1：消息的读写
1 from multiprocessing import Queue
2
3
4 # 初始化一个Queue对象，最多可接收3条消息
5 q = Queue(3)
6 q.put("msg1")
7 q.put("msg2")
8 print(q.full()) # 此时消息队列未满，False
9 q.put("msg3")
10 print(q.full()) # True
11
12
13 try:
14 # 堵塞等待2秒，若未能放入新消息，则抛出异常
15 q.put("msg4", True, 2)
16 except:
17 print("消息队列已满，现有消息数量为：%d" % q.qsize())
18
19 try:
20 q.put_nowait("msg4")
21 except:
22 print("消息队列已满，现有消息数量为：%d" % q.qsize())
23
24
25 # 推荐方式：写消息时，先判断消息队列是否已满，再写入
26 if not q.full():
27 q.put_nowait("msg4")
28
29
30 # 读消息时，先判断消息队列是否为空，再读取
31 if not q.empty():
32 for i in range(q.qsize()):
33 print(q.get_nowait())
执行结果：
False True 消息队列已满，现有消息数量为：3 消息队列已满，现有消息数量为：3 msg1 msg2 msg3
示例2：在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据
1 from multiprocessing import Process, Queue
2 import time
3 import os
4 import random
5
6
7 # 写数据进程要执行的函数
8 def write(q):
9 for value in "ABC":
10 print("put '%s' to queue..." % value)
11 if not q.full():
12 q.put(value)
13 time.sleep(random.random())
14
15 # 读数据进程要执行的函数
16 def read(q):
17 while True:
18 if not q.empty():
19 value = q.get(True)
20 print("get '%s' from queue..." % value)
21 time.sleep(random.random())
22 else:
23 break
24
25
26 if __name__ == "__main__":
27 # 父进程创建Queue，并传给各个子进程
28 q = Queue()
29 pw = Process(target=write, args=(q,))
30 pr = Process(target=read, args=(q,))
31 pw.start()
32 pw.join() # 等待pw结束
33 pr.start()
34 pr.join() # 等待pr结束
35 print("所有数据都写入并且读完")
执行结果：
put 'A' to queue... put 'B' to queue... put 'C' to queue... get 'A' from queue... get 'B' from queue... get 'C' from queue... 所有数据都写入并且读完
示例3：进程池中的Queue
如果要使用Pool创建进程并进行进程间通信，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否则会得到一条如下的错误信息：
RuntimeError: Queue objects should only be shared between processes through inheritance.
1 from multiprocessing import Pool, Manager
2 import time
3 import os
4 import random
5
6
7 # 写数据进程要执行的函数
8 def write(q):
9 print("写进程(%d)启动，父进程为%d" % (os.getpid(), os.getppid()))
10 for value in "ABC":
11 print("put '%s' to queue..." % value)
12 if not q.full():
13 q.put(value)
14 time.sleep(random.random())
15
16 # 读数据进程要执行的函数
17 def read(q):
18 print("读进程(%d)启动，父进程为%d" % (os.getpid(), os.getppid()))
19 while True:
20 if not q.empty():
21 value = q.get(True)
22 print("get '%s' from queue..." % value)
23 time.sleep(random.random())
24 else:
25 break
26
27
28 if __name__ == "__main__":
29 print("主进程启动：id=%s" % os.getpid())
30 # 父进程创建Queue，并传给各个子进程
31 q = Manager().Queue()
32 po = Pool()
33 # 使用阻塞模式创建进程，这样就不需要在reader中使用死循环了，可以让writer完全执行完成后，再用reader去读取
34 po.apply(write, (q, ))
35 po.apply(read, (q, ))
36 po.close()
37 po.join()
38 print("主进程结束：id=%s" % os.getpid())
39
执行结果：
主进程启动：id=10336 写进程(10776)启动，父进程为10336 put 'A' to queue... put 'B' to queue... put 'C' to queue... 读进程(1340)启动，父进程为10336 get 'A' from queue... get 'B' from queue... get 'C' from queue... 主进程结束：id=10336
来源：https://www.cnblogs.com/juno3550/p/12386455.html