Python爬虫效率提升实战：异步协程与线程池对比

周予安

发布时间：2026-10-14| 5人浏览过

原创

本文详细解析Python中提升爬虫效率的两种主流方案：基于aiohttp的单线程多任务异步协程，以及结合requests模块的线程池技术。通过Flask模拟服务端与具体代码示例，对比两者在并发请求下的耗时表现，并介绍异步回调与数据解析的最佳实践，帮助开发者根据场景选择最优加速策略。

异步协程基础概念

单线程结合多任务异步协程是提升爬虫性能的一种核心思路。

协程（Coroutine）

在定义函数（特别是特殊函数）时，使用async关键字进行修饰。函数被调用后，其内部语句不会立即执行，而是返回一个协程对象。

任务对象（Task）

任务对象可视为高级的协程对象，即对协程的进一步封装，本质仍是一种特殊的函数。任务对象必须注册到事件循环对象中才能运行。此外，还可以给任务对象绑定回调函数，这在爬虫的数据解析环节非常有用。

事件循环（Event Loop）

可以将事件循环理解为一个装载任务对象的容器。当启动事件循环对象时，其中存储的所有任务对象将开始异步执行。

在特殊函数内部，严禁编写不支持异步请求的模块（如time、requests等）。虽然代码运行不会报错，但无法实现真正的异步效果。

常见的替换方案包括：将time.sleep替换为asyncio.sleep，将requests替换为aiohttp。


import asyncio
import time

start_time = time.time()
async def get_request(url):
  await asyncio.sleep(2)
  print(url,'下载完成!')

urls = [
  'www.1.com',
  'www.2.com',
]

task_lst = [] # 任务对象列表
for url in urls:
  c = get_request(url) # 协程对象
  task = asyncio.ensure_future(c) # 任务对象
  # task.add_done_callback(...)  # 绑定回调
  task_lst.append(task)

loop = asyncio.get_event_loop() # 事件循环对象
loop.run_until_complete(asyncio.wait(task_lst)) # 注册,手动挂起

线程池加速方案

另一种提升效率的方法是：线程池结合requests模块。


# 线程池
import time
from multiprocessing.dummy import Pool

start_time = time.time()
url_list = [
  'www.1.com',
  'www.2.com',
  'www.3.com',
]
def get_request(url):
  print('正在下载...',url)
  time.sleep(2)
  print('下载完成!',url)

pool = Pool(3)
pool.map(get_request,url_list)
print('总耗时:',time.time()-start_time)

以下是两种主要的爬虫加速方法。

首先，需要启动一个Flask服务端用于模拟测试环境。


from flask import Flask
import time

app = Flask(__name__)

@app.route('/bobo')
def index_bobo():
  time.sleep(2)
  return 'hello bobo!'

@app.route('/jay')
def index_jay():
  time.sleep(2)
  return 'hello jay!'

@app.route('/tom')
def index_tom():
  time.sleep(2)
  return 'hello tom!'

if __name__ == '__main__':
  app.run(threaded=True)

具体实现涉及aiohttp模块与单线程多任务异步协程的配合。


import asyncio
import aiohttp
import requests
import time

start = time.time()
async def get_page(url):
  # page_text = requests.get(url=url).text
  # print(page_text)
  # return page_text
  async with aiohttp.ClientSession() as s: #生成一个session对象
    async with await s.get(url=url) as response:
      page_text = await response.text()
      print(page_text)
  return page_text

urls = [
  'http://127.0.0.1:5000/bobo',
  'http://127.0.0.1:5000/jay',
  'http://127.0.0.1:5000/tom',
]
tasks = []
for url in urls:
  c = get_page(url)
  task = asyncio.ensure_future(c)
  tasks.append(task)
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

end = time.time()
print(end-start)

# 异步执行!
# hello tom!
# hello bobo!
# hello jay!
# 2.0311079025268555


'''
aiohttp模块实现单线程+多任务异步协程
并用xpath解析数据
'''
import aiohttp
import asyncio
from lxml import etree
import time

start = time.time()
# 特殊函数:请求的发送和数据的捕获
# 注意async with await关键字
async def get_request(url):
  async with aiohttp.ClientSession() as s:
    async with await s.get(url=url) as response:
      page_text = await response.text()
      return page_text    # 返回页面源码

# 回调函数,解析数据
def parse(task):
  page_text = task.result()
  tree = etree.HTML(page_text)
  msg = tree.xpath('/html/body/ul//text()')
  print(msg)

urls = [
  'http://127.0.0.1:5000/bobo',
  'http://127.0.0.1:5000/jay',
  'http://127.0.0.1:5000/tom',
]
tasks = []
for url in urls:
  c = get_request(url)
  task = asyncio.ensure_future(c)
  task.add_done_callback(parse) #绑定回调函数!
  tasks.append(task)
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

end = time.time()
print(end-start)

另一种实现方式是requests模块结合线程池。


import time
import requests
from multiprocessing.dummy import Pool

start = time.time()
urls = [
  'http://127.0.0.1:5000/bobo',
  'http://127.0.0.1:5000/jay',
  'http://127.0.0.1:5000/tom',
]
def get_request(url):
  page_text = requests.get(url=url).text
  print(page_text)
  return page_text

pool = Pool(3)
pool.map(get_request, urls)
end = time.time()
print('总耗时:', end-start)

# 实现异步请求
# hello jay!
# hello bobo!
# hello tom!
# 总耗时: 2.0467123985290527