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
' %(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

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

协程不是真的存在

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