一、概念
进程池，在进程池中有5(自定义)个进程，有n个任务等待进入进程池，一次只能进入5个任务
优点：节省了n-5个进程的内存空间，n个进程的创建时间
信号量：一次只允许固定的进程进行操作，进程的内存空间和创建时间都没减少，只减轻了操作系统的压力
二、常用方法
close()方法
作用：进程池禁止任务进入
格式：obj.close()
join()方法的
作用：感知进程池的任务结束
格式：obj.join()
三、map()方法
特点：异步，自带close()方法和join()方法
格式：map(函数名, 可迭代对象)
import time from multiprocessing import Pool def test(n): n = n + 1 time.sleep(0.5) print(n) if __name__ == ‘__main__‘: p = Pool(5) # 进程池中有5个任务 p.map(test, range(30)) # 参数是0-29,执行30个任务，是异步执行，打印的结果不是按顺序执行
from multiprocessing import Pool import time def str_add(s): new_s = s + ‘_sb‘ time.sleep(0.5) print(new_s) if __name__ == ‘__main__‘: p = Pool(3) # 进程池3个进程 p.map(str_add, [‘joker‘, ‘mark‘, ‘peter‘, ‘hacker‘, ‘richard‘]) # 5个任务, 异步
from multiprocessing import Pool import time import random def str_add(s): new_s = s + ‘**‘ time.sleep(random.randrange(1, 3)) print(new_s) if __name__ == ‘__main__‘: p = Pool(3) # 进程池3个进程 p.map(str_add, ‘hello_world‘) # 5个任务, 异步
四、apply()
特点：同步
格式：obj.apply(函数名, args=tuple)
from multiprocessing import Pool import time def str_add(s): new_s = s + ‘**‘ time.sleep(0.5) print(new_s) if __name__ == ‘__main__‘: p = Pool(3) # 进程池3个进程 for i in range(3): p.apply(str_add, args=(‘cv%s‘ % i,)) # 同步，结果一个接着一个打印
五、apply_async
特点：异步，需要close()和join()方法
格式：obj.apply_async(函数名, args=tuple)
from multiprocessing import Pool import time def str_add(s): new_s = s + ‘**‘ time.sleep(0.5) print(new_s) if __name__ == ‘__main__‘: p = Pool(3) # 进程池3个进程 for i in range(10): p.apply_async(str_add, args=(‘cv%s‘ % i,)) # 异步，结果一个接着一个打印 p.close() # 结束进程池接收任务 p.join() # 感知进程池中的任务执行结束
六、返回值
1、map()
""" map()方法自带close()方法和join()方法 所有的进程都执行完毕后，赋值给ret """ from multiprocessing import Pool import time def mun_mul(n): time.sleep(0.5) return n*n if __name__ == ‘__main__‘: p = Pool(3) # 进程池3个进程 ret = p.map(mun_mul, range(10)) print(ret) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
2、apply
""" apply()，进程同步，一个一个打印返回值 """ from multiprocessing import Pool import time def mun_mul(n): time.sleep(0.5) return n*n if __name__ == ‘__main__‘: p = Pool(3) # 进程池3个进程 for i in range(10): ret = p.apply(mun_mul, args=(i, )) # 同步 print(ret)
""" apply_async()是异步，但打印的数据是一个接着一个 原因：get()方法 """ from multiprocessing import Pool import time def mun_mul(n): time.sleep(0.5) return n*n if __name__ == ‘__main__‘: p = Pool(3) # 进程池3个进程 for i in range(10): ret = p.apply_async(mun_mul, args=(i, )) # 异步 # print(ret) # 结果是对象 print(ret.get())
from multiprocessing import Pool import time def mun_mul(n): time.sleep(0.7) return n*n if __name__ == ‘__main__‘: p = Pool(4) # 进程池3个进程 ret_li = [] for i in range(10): ret = p.apply_async(mun_mul, args=(i, )) # 异步 ret_li.append(ret) # print(ret) # 结果是对象 for o in ret_li: print(o.get())
七、回调函数
""" 回调函数：callback=函数名 函数名的参数，是func的返回值 回到的进程是主进程 """ from multiprocessing import Pool import os import time def mun_mul(n): time.sleep(0.7) print(‘1 ---- %s‘ % os.getppid()) return 2 * n def test2(m): print(‘2 ---- %s‘ % os.getppid()) print(m*2) if __name__ == ‘__main__‘: p = Pool(4) # 进程池3个进程 print(‘3 ---- %s‘ % os.getppid()) ret_li = [] for i in range(10): p.apply_async(mun_mul, args=(i, ), callback=test2) # 异步 p.close() p.join()
原文：https://www.cnblogs.com/wt7018/p/11062237.html