用 Python 实现并发 HTTP 请求：提升 Web 爬虫抓取效率的最佳实践

原创于 2025-08-22 09:22:02 发布 · 612 阅读

CC 4.0 BY-SA版权

文章标签：

引言：高效爬虫的关键

在 Web 爬虫的开发过程中，爬取大量数据时，单线程的 HTTP 请求可能会导致程序的执行效率低下，尤其是在需要处理多个页面或大量数据时，爬虫的执行时间往往会成倍增加。为了提高爬取效率，并发请求成为了解决这一问题的必然选择。

在 Python 中，常用的并发处理方法有线程、进程以及异步 I/O等方式。通过合理使用这些技术，可以显著加快 Web 爬虫的抓取速度和响应时间。

本文将详细介绍如何使用 Python 实现并发 HTTP 请求，并提升 Web 爬虫的抓取效率。我们将使用几种常见的 Python 并发方式，包括 requests+ThreadPoolExecutor、aiohttp 等，逐步实现性能优化。

一、并发爬虫的基本概念

1.1. 什么是并发请求？

并发请求意味着同时发出多个请求，而不必等待每个请求完成后再发出下一个。这种技术能够显著减少程序的等待时间，特别适用于 I/O 密集型任务，如网络请求、文件读取等。通过并发，你可以在等待某个请求响应的同时，处理其他请求，从而节省时间。

1.2. 常见并发编程方式

多线程：多个线程共享同一进程的内存空间，通过ThreadPoolExecutor管理线程池。
多进程：每个进程都有独立的内存空间，适合 CPU 密集型任务，但由于进程间通信开销较大，不适合用于 I/O 密集型任务。
异步 I/O：通过事件循环机制非阻塞地处理任务，适用于大量 I/O 操作的场景（如网络请求）。

二、使用 `ThreadPoolExecutor` 实现并发请求

ThreadPoolExecutor 是 Python 中标准库 concurrent.futures 模块提供的线程池工具，能够在固定数量的线程中管理并发任务。

2.1 安装请求库

首先，我们需要安装常用的 HTTP 请求库 requests，它是用于发送 HTTP 请求的基础库。

pip install requests

2.2 示例代码：使用 `ThreadPoolExecutor` 实现并发请求

import requests
from concurrent.futures import ThreadPoolExecutor

# 目标 URL 列表
urls = [
    'http://example.com/page1',
    'http://example.com/page2',
    'http://example.com/page3',
    'http://example.com/page4',
    'http://example.com/page5',
]

# 定义请求函数
def fetch_url(url):
    try:
        response = requests.get(url)
        print(f"URL: {url} | Status Code: {response.status_code}")
        return response.text  # 返回页面内容
    except requests.RequestException as e:
        print(f"Error fetching {url}: {e}")
        return None

# 使用 ThreadPoolExecutor 进行并发请求
def fetch_all_urls(urls):
    with ThreadPoolExecutor(max_workers=5) as executor:
        results = executor.map(fetch_url, urls)
    return list(results)

# 执行请求并获取结果
results = fetch_all_urls(urls)

2.3 解析代码

ThreadPoolExecutor(max_workers=5)：创建一个最大并发数为 5 的线程池。
executor.map(fetch_url, urls)：并发执行 fetch_url 函数，处理所有 URL。executor.map 会自动将 URL 列表传递给 fetch_url 函数。
结果会返回每个请求的响应内容，可以进一步处理（例如保存 HTML 内容）。

通过使用 ThreadPoolExecutor，我们可以大幅提升请求的并发效率，减少请求总时间。

三、使用 `aiohttp` 实现异步 HTTP 请求

对于大量 HTTP 请求的抓取，异步 I/O 是一种非常高效的并发方式。通过异步 I/O，可以在等待响应的过程中不阻塞主线程，继续执行其他请求。

aiohttp 是 Python 中常用的异步 HTTP 客户端库，适用于处理大量并发的 HTTP 请求。

3.1 安装 `aiohttp`

pip install aiohttp

3.2 示例代码：使用 `aiohttp` 实现并发请求

import aiohttp
import asyncio

# 目标 URL 列表
urls = [
    'http://example.com/page1',
    'http://example.com/page2',
    'http://example.com/page3',
    'http://example.com/page4',
    'http://example.com/page5',
]

# 定义异步请求函数
async def fetch_url(session, url):
    try:
        async with session.get(url) as response:
            print(f"URL: {url} | Status Code: {response.status}")
            return await response.text()
    except Exception as e:
        print(f"Error fetching {url}: {e}")
        return None

# 异步请求所有 URL
async def fetch_all_urls(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        return await asyncio.gather(*tasks)

# 执行异步请求
loop = asyncio.get_event_loop()
results = loop.run_until_complete(fetch_all_urls(urls))

3.3 解析代码

aiohttp.ClientSession()：创建一个异步 HTTP 请求会话。
async with session.get(url)：使用 async with 语法进行异步请求。
await response.text()：异步获取响应内容。
asyncio.gather(*tasks)：并发执行所有任务，tasks 是异步请求列表。

3.4 为什么使用 `aiohttp` 更高效？

异步 I/O：不阻塞主线程，多个请求同时进行，尤其适用于大量 I/O 操作。
内存效率：异步处理的开销远低于线程和进程，在处理大量请求时，内存消耗更少。

四、使用 `requests` + `ThreadPoolExecutor` vs `aiohttp` 的对比

4.1 性能对比

ThreadPoolExecutor：适合中小规模的并发请求（如几十到几百个请求）。由于每个线程独立工作，创建线程的开销会增加。
aiohttp：适合大量高并发请求（如上千个请求），通过异步 I/O 机制极大地减少线程开销，能够更高效地处理大量请求。

4.2 简单性 vs 高效性

ThreadPoolExecutor：代码简单易懂，适用于中等规模的爬虫任务。
aiohttp：需要理解异步编程的概念，适合开发高效的分布式爬虫。

五、总结与优化建议

选择并发方式：对于中小规模的任务，可以选择 ThreadPoolExecutor；对于需要高并发、低延迟的任务，建议使用 aiohttp 异步编程。
优化请求效率：使用 Session 复用连接，减少每个请求的连接开销。
遵守网站的 robots.txt 规则：避免恶意爬取，防止被封 IP。
限速与防止封锁：使用 time.sleep() 限制请求频率，使用代理 IP 分散风险。

通过合理的并发策略，Python 爬虫的效率将得到极大的提升，从而加速数据抓取的过程。无论是选择线程池、异步 I/O 还是其他方式，都能根据需求灵活调配，实现最优性能。

欢迎留言交流你在 Web 爬虫中的并发请求经验与优化策略！