进程池是主程序结束就自动结束,map是自带close方法和join方法 (执行(进程或线程)结束才会继续向后执行)
线程池是主进程结束不影响线程池
进程池: 进程的创建和销毁是很有消耗的,影响代码执行效率
map:异步提交任务,并且传参需要可迭代类型的数据,自带close和join功能
测试多进程和进程池的效率对比:
import time
from multiprocessing import Process,Pool
def f1(m):
for i in range(5):
m += i
if __name__ == '__main__':
# 进程池设置三个进程
p1 = Pool(3)
# 创建进程时得到时间戳
p1_go_time = time.time()
# 参数1放进程的逻辑,参数2放可迭代对象.map是异步提交任务,但自带close和join
p1.map(f1,range(100))
# 所有进程结束后得到一个时间戳
p1_end_time = time.time()
p1_time = p1_end_time - p1_go_time
p2_lis = []
# 创建进程时得到时间戳
p2_go_time = time.time()
for i in range(100):
# 创建进程对象,把循环的内容当做参数,传给函数
p2 = Process(target=f1,args=(i,))
p2.start()
# 把进程对象都添加到列表中,方便让对象都join.
p2_lis.append(p2)
for i in p2_lis:
#把每个创建的进程对象都join,进程最慢的执行完之后,继续向下执行
#假如不加join的话,就是for循环创建完所有进程之后,直接向后执行,而子进程并没有执行完.
i.join()
# 所有多进程结束后得到一个时间戳
p2_end_time = time.time()
p2_time = p2_end_time - p2_go_time
print("进程池耗时:",p1_time)
print("多进程耗时:", p2_time)
res = apply( f1,args=(i,) ) #同步执行任务,必须等任务执行结束才能给进程池提交下一个任务,可以直接拿到返回结果res
import time
from multiprocessing import Process,Pool
def f1(n):
time.sleep(1)
# print(n)
return n*n
if __name__ == '__main__':
pool = Pool(4)
for i in range(10):
print('xxxxxx')
res = pool.apply(f1,args=(i,))
print(res)
res_obj = apply_async( f1,args=(i,) ) #异步提交任务,可以直接拿到结果对象,从结果对象里面拿结果,要用get方法,get方法会阻塞程序,没有拿到结果会一直等待.
close : 锁住进程池,防止有其他的新的任务在提交给进程池
join : 等待着进程池将自己里面的任务都执行完
get : 拿到函数执行的结果
import time
from multiprocessing import Process, Pool
def f1(n):
time.sleep(2)
print(n)
return n * n
if __name__ == '__main__':
pool = Pool(4)
res_list = []
for i in range(10):
print('xxxx')
# 异步给进程池提交任务
res = pool.apply_async(f1, args=(i,))
res_list.append(res)
print('等待所有进程执行完')
pool.close() #锁住进程池,意思就是不让其他的程序再往这个进程池里面提交任务了
pool.join() #等进程执行完之后,才继续向下执行
print('所有进程执行结束')
time.sleep(2)
# 打印结果,如果异步提交之后的结果对象
for i in res_list:
print(i.get())
print("主程序结束")
线程池:
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
t = ThreadPoolExecutor(4) #默认的线程个数是cpu个数 * 5
p = ProcessPoolExecutor(4) #默认的进程个数是cpu个数
t.map(f1,可迭代的对象) #异步执行
import time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def f1(n):
time.sleep(1)
print(n)
if __name__ == '__main__':
t = ThreadPoolExecutor(5)
t.map(f1,range(10))
t.shutdown()
print('主程序结束')
def f1(n1,n2):
print(n1,n2)
t.submit(f1,11,12) # 异步提交任务 ,第一个参数是函数,后面是无敌传参,看函数需要几个参数
res = t.submit(f1,11,12)
res.result() # 和进程池的get方法一样,如果没有结果,会等待,阻塞程序
shutdown() # close+join,锁定线程池,等待线程池中所有已经提交的任务全部执行完毕
import time
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def f1(n,m):
time.sleep(1)
print(n)
return n+m
if __name__ == '__main__':
t = ThreadPoolExecutor(5)
t_lis = []
for i in range(10):
ret = t.submit(f1,i,5)
t_lis.append(ret)
t.shutdown()
for i in t_lis:
print(i.result())
print('主程序结束')