一、进程池
进程池也是通过事先划分一块系统资源区域，这组资源区域在服务器启动时就已经创建和初始化，用户如果想创建新的进程，可以直接取得资源，从而避免了动态分配资源(这是很耗时的)。
线程池内子进程的数目一般在3～10个之间，当有新的任务来到时，主进程将通过某种方式选择进程池中的某一个子进程来为之服务。相比于动态创建子进程，选择一个已经存在的子进程的代价显得小得多（进程开启过多，效率反而会下降，开启进程是需要占用系统资源的，而且开启多余核数目的进程也无法做到并行）。
Pool可以提供指定数量的进程，供用户调用，当有新的请求提交到pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到规定最大值，那么该请求就会等待，直到池中有进程结束，就重用进程池中的进程。
multiprocess.Pool模块
Pool([numprocess [,initializer [, initargs]]]):创建进程池 numprocess:要创建的进程数，如果省略，将默认使用cpu_count()的值，如果指定numprocess为3，则进程池会从无到有创建三个进程，然后自始至终使用这三个进程去执行所有任务，不会开启其他进程 initializer：是每个工作进程启动时要执行的可调用对象，默认为None initargs：是要传给initializer的参数组
主要方法
p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
'''此方法的结果是AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，
将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。'''
p.close():关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
P.jion():等待所有工作进程退出。此方法只能在close（）或teminate()之后调用
map()：Pool类中的map方法，与内置的map函数用法行为基本一致，即针对每个参数都进行func()处理，它会使进程阻塞直到结果一起整体返回。
注意：虽然第二个参数是一个迭代器，但在实际使用中，必须在整个队列都就绪后，程序才会运行子进程。
terminal()：结束工作进程，不在处理未处理的任务。
join()：主进程阻塞等待子进程的退出，join方法必须在close或terminate之后使用。
例子1
from multiprocessing import Pool
import time
import os
def func1(n):
print("子进程%s开始%s"%(n,os.getpid()))
time.sleep(2)
print("子进程%s结束%s"%(n,os.getpid()))
return n
def func2(n):
for i in range(10):
print(n+2)
if __name__ == "__main__":
p = Pool(5) #5个进程,默认是cpu的核心数
res = p.map(func1,range(10)) #10个任务，参数必须是可迭代的
print(res) #返回值是带所有子进程的结果的列表
# 默认异步的执行任务,且自带close和join
#
# p.map(funcname,iterable) 默认异步的执行任务,且自带close和join
例子2
from multiprocessing import Pool
import time
import os
def func(n):
print("进程池中的进程开始%s"%n,os.getpid())
time.sleep(2)
print("进程池中的进程结束%s"%n,os.getpid())
if __name__ == "__main__":
pool = Pool(5)
for i in range(20):
# pool.apply(func,args=(i,)) #同步的执行
pool.apply_async(func,args=(i,)) #异步的执行
pool.close() #结束进程池提交任务
pool.join() # 感知进程池中的任务执行结束
进程池的返回值
方法apply_async()和map_async（）的返回值是AsyncResul的实例obj对象。
实例具有以下方法
obj.get():返回结果，如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达，将引发异常。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
obj.ready():如果调用完成，返回True
obj.successful():如果调用完成且没有引发异常，返回True，如果在结果就绪之前调用此方法，引发异常
obj.wait([timeout]):等待结果变为可用。
obj.terminate()：立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收，将自动调用此函数
例子1
from multiprocessing import Pool
import time
def func(n):
print("进程%s"%n)
time.sleep(2)
return n*n
if __name__ == "__main__":
p = Pool(5) #5个进程
res_l = []
for i in range(10): #
# res = p.apply(func,args=(i,)) #同步
# print(res)
# res_l.append(res)
res = p.apply_async(func,args=(i,)) #异步
# print(res.get()) #注意异步时提交返回值需要用get()方法获取,get()方法自带join()效果，
#如果在这里打印则会出现和同步时一样的效果
res_l.append(res)
# 同步
# print(res_l)
# 异步
for i in res_l:
print(i.get())
执行结果：同步时是一个接一个的慢慢返回结果，异步时很快的返回整个结果，可能会出现顺序乱的情况
例子2
import time
from multiprocessing import Pool
def func(i):
time.sleep(0.5)
return i*i
if __name__ == '__main__':
p = Pool(5)
ret = p.map(func,range(10))
print(ret)
执行结果：整体一起输出，map()自带join()效果，因此会阻塞，然后整体一起输出结果
进程池的回调函数
可以为进程池或线程池内的每个进程或线程绑定一个函数，该函数在进程或线程的任务执行完毕后自动触发，并接收任务的返回值当作参数，该函数称为回调函数。
简单的说就是进程池中任何一个任务一旦处理完了，就立即告知主进程：我好了，你可以处理我的结果了。主进程则调用一个函数去处理该结果，该函数即回调函数。
我们可以把耗时间（阻塞）的任务放到进程池中，然后指定回调函数（主进程负责执行），这样主进程在执行回调函数时就省去了I/O的过程，直接拿到的是任务的结果。
简单例子
from multiprocessing import Pool
import time
import os
def func1(n):
print("子进程",os.getpid())
time.sleep(1)
return n*n
def func2(m):
print("回调函数",os.getpid())
print("回调函数",m)
if __name__ == "__main__":
p = Pool(5)
for i in range(10):
p.apply_async(func1,args=(i,),callback=func2)
p.close()
p.join()
print("主进程",os.getpid())
# 从执行结果可以看出执行回调函数的进程是主进程
回调函数最多的在爬虫程序过程中使用的较多，爬取网页用子进程，处理数据用回调函数。爬虫：即网络爬虫，可以简单的理解为爬取网页源码的程序，在python中可以使用requests模块实现。
例子1
import requests
from multiprocessing import Pool
def get(url):
responds = requests.get(url)
if responds.status_code == 200:
return url,responds.content.decode("utf-8")
def call_back(args):
url,content = args
print(url,len(content))
if __name__ == "__main__":
url_li = ["https://www.bitmain.com/",
"https://www.feixiaohao.com/",
"https://www.jinse.com/",
"http://www.avalonminer.shop/",
"http://www.innosilicon.com/html/product/index.html"
]
p = Pool(4)
for url in url_li:
p.apply_async(get,args=(url,),callback=call_back)
p.close()
p.join()
# 在爬虫爬取网页过程中，主要耗时间的是爬取的过程，
# 假设这里的call_back()是放在子进程中执行，则耗费了更多的时间，
# 与此同时主进程一直是空闲的，这里的call_back()放在主进程执行，节省了程序执行的时间
例子2
import re
from urllib.request import urlopen
import requests
from multiprocessing import Pool
def get_page(url,pattern):
response=urlopen(url).read().decode('utf-8') #这里拿到的是有格式的网页源码
return pattern,response # 正则表达式编译结果 网页内容
def get(url,pattern):
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) '
'Chrome/51.0.2704.63 Safari/537.36'}
responds = requests.get(url,headers=headers,timeout=30)
res = responds.content.decode("utf-8") #这里拿到的是简化版的无格式的网页源码
return pattern,res
def parse_page(info):
pattern,page_content=info
print("网页内容长度",len(page_content))
# print(page_content)
res=re.findall(pattern,page_content)
for item in res:
dic={
'index':item[0].strip(),
'title':item[1].strip(),
'actor':item[2].strip(),
'time':item[3].strip(),
}
print(dic)
if __name__ == '__main__':
regex = r'<dd>.*?<.*?class="board-index.*?>(d+)</i>.*?title="(.*?)".*?class="movie-item-info".*?<p class="star">(.*?)</p>.*?<p class="releasetime">(.*?)</p>'
pattern1=re.compile(regex,re.S)
url_dic={'http://maoyan.com/board/7':pattern1}
p=Pool()
res_l=[]
for url,pattern in url_dic.items():
# res=p.apply_async(get_page,args=(url,pattern),callback=parse_page)
res=p.apply_async(get,args=(url,pattern),callback=parse_page)
res_l.append(res)
for i in res_l:
i.get()