运维开发网
广告位招商联系QQ:123077622
 
广告位招商联系QQ:123077622

python —— 池

运维开发网 https://www.qedev.com 2020-03-09 07:33 出处:网络 作者:运维开发网整理
1. 池 池分为:进程池、线程池 池:预先的开启固定个数的进程数/线程数,当任务来临的时候,直接提交给已经开好的进程 / 线程,让这个进程 / 线程去执行就可以了。

1. 池

池分为:进程池、线程池

池:预先的开启固定个数的进程数/线程数,当任务来临的时候,直接提交给已经开好的进程 / 线程,让这个进程 / 线程去执行就可以了。

池节省了进程、线程的开启、关闭、切换需要的时间,并且减轻了操作系统调度的负担。

concurrent.futures模块中:ProcessPoolExcutor类(进程池)、ThreadPoolExcutor类(线程池)

1.1 进程池

进程池缺点:

  • 开销大
  • 一个池中的任务个数限制了我们程序的并发个数
# 没有参数和返回值
import os
import time
import random
from concurrent.futures import ProcessPoolExecutor
# submit + shutdown
def func():
    print('start',os.getpid())
    time.sleep(random.randint(1,3))
    print('end', os.getpid())
if __name__ == '__main__':
    p = ProcessPoolExecutor(5)
    for i in range(10):
        p.submit(func)
    p.shutdown()   # 关闭池之后就不能继续提交任务,并且会阻塞,直到已经提交的任务完成
    print('main',os.getpid())
# 任务的参数 + 返回值
def func(i,name):
    print('start',os.getpid())
    time.sleep(random.randint(1,3))
    print('end', os.getpid())
    return '%s * %s'%(i,os.getpid())
if __name__ == '__main__':
    p = ProcessPoolExecutor(5)
    ret_l = []
    for i in range(10):
        ret = p.submit(func,i,'alex')
        ret_l.append(ret)
    for ret in ret_l:
        print('ret-->',ret.result())  # ret.result() 同步阻塞
    print('main',os.getpid())

1.2 线程池

# 示例
from concurrent.futures import ThreadPoolExecutor
def func(i):
    print('start', os.getpid())
    time.sleep(random.randint(1,3))
    print('end', os.getpid())
    return '%s * %s'%(i,os.getpid())
tp = ThreadPoolExecutor(20)

# 方法一:
ret = tp.map(func,range(20))  # a
for i in ret:  # b
    print(i)  # c
    
# a,b,c三行 相当于 下面1,2,3,4,5,6六行

# 方法二:
# ret_l = []  # 1
# for i in range(20):  # 2
#     ret = tp.submit(func,i)  # 3
#     ret_l.append(ret)  # 4
tp.shutdown()
print('main')
# for ret in ret_l:  # 5
#     print(ret.result())  # 6

1..3 回调函数

对象.add_done_callback(子线程执行完毕之后要执行的代码对应的函数名)

效率高

执行完子线程任务之后直接调用对应的回调函数

爬取网页:需要等待数据传输和网络上的响应高IO操作的 — 交子线程完成

分析网页:没有什么IO操作 — 这个操作没必要在子线程完成,交给回调函数完成

add_done_callback
# 示例:爬虫
import requests
from concurrent.futures import ThreadPoolExecutor
def get_page(url):
    res = requests.get(url)
    return {'url':url,'content':res.text}

def parserpage(ret):
    dic = ret.result()
    print(dic['url'])
tp = ThreadPoolExecutor(5)
url_lst = [
    'http://www.baidu.com',
    'http://www.cnblogs.com', 
    'http://www.douban.com', 
    'http://www.tencent.com',
    'http://www.xinhuanet.com/',
    'https://www.toutiao.com/',
]
ret_l = []
for url in url_lst:
    ret = tp.submit(get_page,url)
    ret_l.append(ret)
    ret.add_done_callback(parserpage)

1.4 总结

ThreadPoolExcutor类
ProcessPoolExcutor类

创建一个池子
tp = ThreadPoolExcutor(池中线程(CPU个数*5)/进程(CPU个数)的个数)
异步提交任务
ret = tp.submit(需要在子线程执行的函数名,参数1,参数2....)
获取返回值
ret.result() 是一个阻塞方法
在异步的执行完所有任务之后,主线程/主进程才开始执行的代码
tp.shutdown() 阻塞 直到所有的任务都执行完毕
map方法
ret = tp.map(需要在子线程执行的函数名(如:func),iterable) 迭代获取iterable中的内容,作为func的参数,让子线程来执行对应的任务
for i in ret: 每一个都是任务的返回值
绑定回调函数
ret.add_done_callback(子线程执行完毕之后要执行的代码对应的函数名)
要在ret对应的任务执行完毕之后,直接继续执行add_done_callback绑定的函数中的内容,并且ret的结果会作为参数返回给绑定的函数

1.做一些操作时是单独开启线程、进程还是池?

  • 1.如果只是开启一个子线程做一件事情,就可以单独开线程
  • 2.有大量的任务等待程序去做,要达到一定的并发数,就开启线程池
  • 3.根据你程序的io操作也可以判定是用池还是不用池?
    • socket的server端:大量的阻塞io —recv、recvfrom、socketserver —— 不用池。
    • 爬虫的时候 —— 用池

2.进程 和 线程都有锁:

  • 所有在线程中能工作的基本都不能在进程中工作
  • 在进程中能够使用的基本在线程中也可以使用

扫码领视频副本.gif

0

精彩评论

暂无评论...
验证码 换一张
取 消