python-day37--concurrent.futures模块 实现进程池与线程池

1.concurrent.futures模块 直接内置就是 异步的提交   ，如果你想同步也可以实现（p.submit(task,i).result()即同步执行）

2.属性和方法：

　　1.submit   提交

　　2.shutdown  关闭池的入口  等池运行结束

 #进程池

 from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor

 import os,time,random

 def task(n):

     print('%s is running' %os.getpid())

     time.sleep(2)

     return n**2

 if __name__ == '__main__':

     p=ProcessPoolExecutor()

     l=[]

     start=time.time()

     for i in range(10):

         obj=p.submit(task,i)

         l.append(obj)

     p.shutdown()

     print('='*30)

     # print([obj for obj in l])      # 结果 都是 future 的对象  [<Future at 0x1461d97d1d0 state=finished returned int>,

                                             # <Future at 0x1461d9c6438 state=finished returned int>]

     print([obj.result() for obj in l])

     print(time.time()-start)

 # 结果：

 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

 6.206435441970825

进程池

 # 线程池

 from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor

 import threading

 import os,time,random

 def task(n):

     print('%s:%s is running' %(threading.currentThread().getName(),os.getpid()))

     time.sleep(2)

     return n**2

 if __name__ == '__main__':

     p=ThreadPoolExecutor()

     l=[]

     start=time.time()

     for i in range(10):

         obj=p.submit(task,i)

         l.append(obj)

     p.shutdown()

     print('='*30)

     print([obj.result() for obj in l])

     print(time.time()-start)

 # 结果：

 ==============================

 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

 2.0046041011810303

线程池

　　进程池 默认个数是CPU个数，而线程池的默认个数是CPU个数的5倍

补充：回调函数

 from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor

 import requests

 import os

 import time

 from threading import currentThread

 def get_page(url):

     print('%s:<%s> is getting [%s]' %(currentThread().getName(),os.getpid(),url))

     response=requests.get(url)

     time.sleep(2)

     return {'url':url,'text':response.text}

 def parse_page(res):

     res=res.result()     #与Pool不同之处，这里的res得到的是对象，需要result一下

     print('%s:<%s> parse [%s]' %(currentThread().getName(),os.getpid(),res['url']))

     with open('db.txt','a') as f:

         parse_res='url:%s size:%s\n' %(res['url'],len(res['text']))

         f.write(parse_res)

 if __name__ == '__main__':

     # p=ProcessPoolExecutor()

     p=ThreadPoolExecutor()

     urls = [

         'https://www.baidu.com',

         'https://www.baidu.com',

         'https://www.baidu.com',

         'https://www.baidu.com',

         'https://www.baidu.com',

         'https://www.baidu.com',

     ]

     for url in urls:

         # multiprocessing.pool_obj.apply_async(get_page,args=(url,),callback=parse_page)

         p.submit(get_page, url).add_done_callback(parse_page)

     p.shutdown()

     print('主',os.getpid())

　　3. map方法

 from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor

 import os,time,random

 def task(n):

     print('%s is running' %os.getpid())

     time.sleep(2)

     return n**2

 if __name__ == '__main__':

     p=ProcessPoolExecutor()

     obj=p.map(task,range(10))

     p.shutdown()

     print('='*30)

     print(list(obj))

3.补充：

单线程下串行十个任务效率不一定低，如果是计算型任务，效率不会低

同步异步指的是提交任务的方式

同步：提交任务（纯计算任务）后在原地等着  并不是阻塞。              等待不一定是发生了阻塞：计算时间过长也会等

因为gil锁，python的一个进程的多个线程不能实现并行，但是可以实现并发

如果你开的线程个数在机器的承受范围之内，开线程效率高，如果不行就需要用线程池

函数实现的协程：yield

单线程中提高效率：看情况再说协程，如果是计算型任务你开协程来回的切，反而降低了效率

协程不是真的存在

单线程不可能同时并行两个任务，但是可以出现并发效果