(7)Pool进程池

(1)# 开启过多的进程并不一定提高你的效率

因为进程池可以实现并行的概念,比Process单核并发的速度要快

# 如果cpu负载任务过多,平均单个任务执行的效率就会低,反而降低执行速度.

1个人做4件事和4个人做4件事

显然后者执行速度更快,

前者是并发,后者是并行

利用进程池,可以开启cpu的并行效果

# apply 开启进程,同步阻塞,每次都要等待当前任务完成之后,在开启下一个

进程,apply是同步阻塞,每个进程必须执行完,才能在开启进程;

# apply_async 开启进程,异步非阻塞,(主进程 和 子进程异步)

注意:进程池不需要start来开启

(2)语法:from threading import Thread,Pool

注意:不用写target

p.apply(函数名,args=(参数)) 有返回值

p.apply_async(函数名=(参数)) 有返回值,是一个[对象.get()]获取

os.cpu_count() 获取cpu核心数

p = Pool(6)

(3)注意;两个要一起用

# 关闭进程池,用户不能在向这个池中创建子进程

p.close()

# 这里加阻塞,直到进程池中所有的子进程执行完毕

p.join()

# (1) 比较pool 和Process 执行速度
'''因为进程池可以实现并行的概念,比Process单核并发的速度要快'''
'''
import os,time
from multiprocessing import Pool,Process

def func(num):
    print("发了第%s封邮件" % (num))
    
if __name__ == "__main__":
    # print(os.cpu_count()) # 获取cpu核心数量
    start = time.time()
    p  = Pool(6)  # 6核心
    for i in range(100):
        # apply_async 用来开启子进程
        p.apply_async(func,args=(i,))

    # 关闭进程池,用户不能在向这个池中创建子进程
    p.close() 
    # 这里加阻塞,直到进程池中所有的子进程执行完毕
    p.join()
    end = time.time()
    print(end-start)
        
    # 单核Process处理100件任务
    start = time.time()
    lst = []
    for i in range(100):
        p = Process(target=func,args= ( i ,))
        p.start()
        lst.append(p)
    for p in lst:
        p.join()
    end = time.time()
    print(end-start)
# 运行完,会发现,并行比单核并发快很多

(4) 进程池.map (与高阶函数map使用方法一样,只不过这个是并发版本)

import os
from multiprocessing import Process

def task(num):

    time.sleep(1)

    print("%s:%s"%(num,os.getpid())) #获取子线程号

    return num ** 2

if __name__ == "__main__":

    p = Pool()

    res = p.map(task,range(20)) #自动close和join

    print(res)

结果[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]