进程池和进程之间的通信
进程池和进程之间的通信
进程池
什么是进程池？
进程池就是预先创建好的进程的耳机和，可以向进程池中进程指派任务，不必反复创建和销毁进程。
使用进程池的好处：
批量创建多个进程，让程序执行完任务之后，再讲进程销毁，下次再有任务是，重新创建新的进程，这样频繁创建和销毁进程太浪费cpu。
更好的方式就是，预先创建好一批进程，为它们分配任务，任务完成之后，还可以再次给他们分配任务，而不是直接销毁。
创建进程池的步骤：
- 1、导入模块
from multiprocessing.pool import Pool- 2、创建进程池对象，指定其中进程的个数：
my_pool = Pool(3) # 默认不写的话，进程池中进程个数默认是cpu的核心数 # os.cpu_count() 获取当前CPU的核心数- 3、向进程中添加任务
my_pool.apply_async(要调用的目标,(传递给目标的参数元组)) # 异步添加，会将任务全部添加到进程池中 my_pool.apply(要调用的目标,(传递给目标的参数元组)) # 同步添加，一次只能添加一个任务，前一任务完成之后，才开始下一个。- 4、关闭进程池，不再向其中添加任务，不会结束所有进程
my_pool.close()- 5、等待进程池所有的进程结束
my_pool.join()multiprocessing.Pool常用函数解析：
- apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给func的关键字参数列表；
- apply(func[, args[, kwds]])：使用阻塞方式调用func
- close()：关闭Pool，使其不再接受新的任务；
- terminate()：不管任务是否完成，立即终止；
- join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用；
Demo:
import os
import random
from multiprocessing.pool import Pool
import time
def task(id):
# 开始时间
start_time = time.time()
print(">>>> %d 任务开始执行， pid = %s" % (id, os.getpid()))
time.sleep(random.random() * 2)
# 结束时间
end_time = time.time()
print(">>>> %d 任务执行完毕， pid = %s， 耗时：%.2f" % (id, os.getpid(), (end_time - start_time)))
def main():
print("父进程pid = %d" % os.getpid())
# 1、创建进程池 指定其中进程的个数
my_pool = Pool(4)
# 2、向进程中添加任务
for _id in range(10):
my_pool.apply_async(task, (_id,))
print("任务添加完成")
# 3、关闭进程池，不再向其中添加任务
my_pool.close()
# 4、等待进程池中所有的进程结束
my_pool.join()
print("任务执行完毕")
if __name__ == '__main__':
main()
运行结果：
父进程pid = 14908
任务添加完成
>>>> 0 任务开始执行， pid = 15392
>>>> 1 任务开始执行， pid = 6672
>>>> 2 任务开始执行， pid = 4452
>>>> 3 任务开始执行， pid = 6236
>>>> 2 任务执行完毕， pid = 4452， 耗时：0.11
>>>> 4 任务开始执行， pid = 4452
>>>> 3 任务执行完毕， pid = 6236， 耗时：0.70
>>>> 5 任务开始执行， pid = 6236
>>>> 5 任务执行完毕， pid = 6236， 耗时：0.38
>>>> 6 任务开始执行， pid = 6236
>>>> 4 任务执行完毕， pid = 4452， 耗时：1.55
>>>> 7 任务开始执行， pid = 4452
>>>> 0 任务执行完毕， pid = 15392， 耗时：1.75
>>>> 8 任务开始执行， pid = 15392
>>>> 7 任务执行完毕， pid = 4452， 耗时：0.08
>>>> 9 任务开始执行， pid = 4452
>>>> 1 任务执行完毕， pid = 6672， 耗时：1.79
>>>> 8 任务执行完毕， pid = 15392， 耗时：0.15
>>>> 9 任务执行完毕， pid = 4452， 耗时：0.84
>>>> 6 任务执行完毕， pid = 6236， 耗时：1.76
任务执行完毕进程和进程之间的通信-Queue
Demo：
import os
import random
from multiprocessing import Queue, Process
import time
def write_task(q):
for s in ("Hello", "World", "Python", "end"):
q.put(s)
print("%s 进程，正在添加数据----%s" % (os.getpid(), s))
time.sleep(random.random() * 2)
print("%s 进程， 将要完成任务" % os.getpid())
def read_task(q):
while True:
msg = q.get()
if msg == "end":
print("%s 进程将要结束。。。" % os.getpid())
break
print("%s 进程，正在读取数据---%s" % (os.getpid(), msg))
time.sleep(random.random() * 2)
def main():
# 创建消息队列
q = Queue()
# 创建进程，
_write = Process(target=write_task, args=(q,))
_read = Process(target=read_task, args=(q,))
# 启动进程
_write.start()
_read.start()
_read.join()
_read.join()
print("父进程完成任务了..............")
if __name__ == '__main__':
main()
运行结果：
15580 进程，正在添加数据----Hello
9596 进程，正在读取数据---Hello
15580 进程，正在添加数据----World
9596 进程，正在读取数据---World
15580 进程，正在添加数据----Python
15580 进程，正在添加数据----end
15580 进程， 将要完成任务
9596 进程，正在读取数据---Python
9596 进程将要结束。。。
父进程完成任务了..............
说明：
初始化Queue对象时，若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接收的消息数量没有上限(直到内存的尽头)
- Queue.qsize():返回当前队列包含的消息数量
- Queue.empty():如果队列为空，返回True，反之False
- Queue.full():如果队列满了，返回True，反之False
- Queue.get([block[, timeout]]):获取队列中的一条消息，然后将其从队列中删除，block默认值为True
- 如果block使用默认值，且没有设置timeout(单位秒)，消息队列如果为空，此时程序将被阻塞(停在读取状态)，知道消息队列读到消息为止，如果设置了timeout，则会等待timeout秒，若还没有读取到任何消息，则会抛出“Queue.Empty”异常。
- 如果block返回值为False，消息队列为空，则会立刻抛出“Queue.Empty”异常。
- Queue.get_nowait():相当于Queue.get(False)
- Queue.put(item,[block[, timeout]]):将item消息写入队列，block默认值为True
- 如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出”Queue.Full”异常；
- 如果block值为False，消息列队如果没有空间可写入，则会立刻抛出”Queue.Full”异常；
- Queue.put_nowait(item):相当于Queue.put(item,False)
进程池中的Queue
如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否则会得到一条如下的错误信息：
RuntimeError: Queue objects should only be shared between processes through inheritance.
Demo:
import os
import random
from multiprocessing.pool import Pool
from multiprocessing import Manager
import time
def write_task(q):
for s in ("Hello", "World", "Python", "end"):
q.put(s)
print("%s 进程，正在添加数据---%s" % (os.getpid(), s))
time.sleep(random.random() * 2)
print("%s 进程，将要结束任务......." % os.getpid())
def read_task(q):
while True:
msg = q.get()
if msg == "end":
print("%s 进程，将要读取完毕...." % os.getpid())
break
print("%s 进程读取到消息%s" % (os.getpid(), msg))
time.sleep(random.random() * 2)
def main():
# 创建进程间通讯的工具
q = Manager().Queue() # 进程池中使用消息队列，必须使用Manager().Queue()
# 创建线程池对象
p = Pool(2)
# 使用同步添加任务的话，程序只能一个任务一个的添加，只能先put再get
p.apply_async(write_task, (q,))
p.apply_async(read_task, (q,))
p.close()
p.join()
print("主进程执行完毕")
if __name__ == '__main__':
main()
执行效果 ：
11532 进程，正在添加数据---Hello
14016 进程读取到消息Hello
11532 进程，正在添加数据---World
14016 进程读取到消息World
11532 进程，正在添加数据---Python
14016 进程读取到消息Python
11532 进程，正在添加数据---end
14016 进程，将要读取完毕....
11532 进程，将要结束任务.......
主进程执行完毕