是根据蚂蚁学Python的视频做的笔记，方便自己后续回顾
视频链接：BV1bK411A7tV
老师的源码
这一份笔记对应的是视频的P7-P8
文章目录- python并发编程笔记5
- P7-Python好用的线程池ThreadPoolExecutor
- 1、线程池的原理
- 1.1、线程的生命周期
- 1.2、线程池是怎么流转的呢
- 2、使用线程池的好处
- 2.1、提升性能:
- 2.2、适用场景:
- 2.3、防御功能:
- 2.4、代码优势:
- 3、ThreadPoolExecutor的使用语法
- 前提：导入对应模块
- 用法1：map函数
- 用法2：future模式
- 4、使用线程池改造爬虫程序
- 注意事项:
- 代码：
- 总结：
- P8-Python使用线程池在Web服务中实现加速
- 1、Web服务的架构以及特点
- Web后台服务的特点:
- 2、使用线程池ThreadPoolExecutor加速
- 使用线程池ThreadPoolExecutor的好处:
- 3、代码用Flask实现Web服务并实现加速
- 总结:
新建线程系统需要分配资源、终止线程系统需要回收资源
如果可以重用线程，则可以减去新建/终止的开销
1.2、线程池是怎么流转的呢由两部分组成
线程池：里面是提前预先建好的线程，线程会被重复使用
任务队列：新的任务而不是直接创建线程
线程池会将任务队列的任务挨个取出依次执行，任务执行完后会取下一个任务执行，若没有任务，则回到线程池，不会进行销毁
2、使用线程池的好处 2.1、提升性能:因为减去了大量新建、终止线程的开销，重用了线程资源;
2.2、适用场景:适合处理突发性大量请求或需要大量线程完成任务、但实际任务处理时间较短
2.3、防御功能:能有效避免系统因为创建线程过多，而导致系统负荷过大相应变慢等问题
2.4、代码优势:使用线程池的语法比自己新建线程执行线程更加简洁
3、ThreadPoolExecutor的使用语法 前提：导入对应模块from concurrent.futures import ThreadPoolExecutor,as_completed用法1：map函数
很简单，注意map结果和入参是顺序对立的（指results 与 urls的顺序是一一对应的）
pool.map(函数，列表）会自动创建和列表等数量（不确定）的线程来处理。
with ThreadPoolExecutor() as pool:
# 传入一个函数名（craw），和参数列表（urls）
results = pool.map(craw, urls)
for result in results:
print(result)
用法2：future模式
更强大，注意如果用as——completed顺序是不定的
with ThreadPoolExecutor() as pool:
# 传入的是单个url，而不是urls，返回的是一个future对象，放进一个futures里面
futures = [ pool.submit(craw, url)
for url in urls ]
# 结果两种遍历方式
# 会根据urls的对应顺序挨个获取future，并且获取结果
for future in futures:
print(future.result())
# as_completed方式，好处：哪个任务先执行完了就先返回
for future in as_completed(futures):
print(future.result())
4、使用线程池改造爬虫程序
注意事项:
视频作者的代码讲的比较快，一些基础我这里普及一下
代码中使用的
zip方法是将urls与对应的的htmls新包为一个元组。
fufturs字典也是为存储跟上述相似的对应关系。
zip实例：
url_list = [1, 2, 3, 4]
html_list = ["a", "b", "c", "d"]
html_list = list(zip(url_list, html_list))
print(html_list)
for url, html in html_list:
print(url, len(html))
结果：
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')] 1 1 2 1 3 1 4 1
代码：
import concurrent.futures
import blog_spider
# craw，使用map方法调用线程池
with concurrent.futures.ThreadPoolExecutor() as pool:
htmls = pool.map(blog_spider.craw, blog_spider.urls)
htmls = list(zip(blog_spider.urls, htmls))
for url, html in htmls:
print(url, len(html))
print("craw over")
# parse 使用future模式调用线程池
with concurrent.futures.ThreadPoolExecutor() as pool:
futures = {}
for url, html in htmls:
future = pool.submit(blog_spider.parse, html)
# 加入到字典的是好处url与future有对应关系
futures[future] = url
# 得到结果 有序的，等所有任务执行完了再返回
# for future, url in futures.items():
# print(url, future.result())
# as_completed方式，好处：哪个任务先执行完了就先返回，相比上面这个是无序的
for future in concurrent.futures.as_completed(futures):
url = futures[future]
print(url, future.result())
总结：
使用这种map或者future模式比02中使用for循环实现thread好用的多
P8-Python使用线程池在Web服务中实现加速 1、Web服务的架构以及特点 Web后台服务的特点:1、Web服务对响应时间要求非常高，比如要求200MS返回
2、Web服务有大量的依赖IO操作的调用，比如磁盘文件、数据库、远程API(暗示使用线程池来加速)
3、Web服务经常需要处理几万人、几百万人的同时请求(不能无限的创建线程池子)
2、使用线程池ThreadPoolExecutor加速 使用线程池ThreadPoolExecutor的好处:1、方便的将磁盘文件、数据库、远程API的IO调用并发执行
2、线程池的线程数目不会无限创建（导致系统挂掉)，具有防御功能
3、代码用Flask实现Web服务并实现加速import flask
import json
import time
from concurrent.futures import ThreadPoolExecutor
app = flask.Flask(__name__)
pool = ThreadPoolExecutor()
def read_file():
time.sleep(0.1)
return "file result"
def read_db():
time.sleep(0.2)
return "db result"
def read_api():
time.sleep(0.3)
return "api result"
# @app.route("/")
# def index():
# result_file = read_file()
# result_db = read_db()
# result_api = read_api()
#
# return json.dumps({
# "result_file": result_file,
# "result_db": result_db,
# "result_api": result_api,
# })
@app.route("/")
def index():
result_file = pool.submit(read_file)
result_db = pool.submit(read_db)
result_api = pool.submit(read_api)
return json.dumps({
"result_file": result_file.result(),
"result_db": result_db.result(),
"result_api": result_api.result(),
})
if __name__ == '__main__':
app.run()
总结:
通过线程池加速Web服务
全局中创建一个pool对象，用submit获取file对象，用result获取结果
