在这里插入图片描述

在网络爬虫开发中，速度永远是我们追求的核心指标之一。当你需要爬取成百上千个页面时，传统的同步爬虫往往会让你陷入漫长的等待。我曾经爬取一个包含500个商品的电商网站，使用requests同步方式花了整整12分钟，而改用aiohttp异步爬虫后，同样的任务只花了28秒，速度提升了近26倍。

今天这篇文章，我将从原理到实战，带你全面掌握aiohttp异步爬虫技术。不仅会教你如何写出第一个异步爬虫，还会深入讲解并发控制、异常处理、重试机制等生产级必备技能，让你真正做到"成倍提升爬取速度"。

一、为什么同步爬虫这么慢？

在讲异步爬虫之前，我们先搞清楚同步爬虫慢的根本原因。

同步爬虫的执行逻辑是线性的：发送请求→等待响应→解析数据→发送下一个请求。在这个过程中，程序大部分时间都在"等待响应"，CPU处于空闲状态。

举个简单的例子：假设每个请求的网络延迟是1秒，那么爬取100个页面至少需要100秒。这100秒里，CPU真正工作的时间可能不到1秒，剩下的99秒都在干等着。

而异步爬虫的核心思想就是：利用等待网络响应的空闲时间，去发送其他请求。这样一来，CPU的利用率会大大提高，整体爬取速度自然就上去了。

二、异步爬虫核心原理

2.1 协程与事件循环

Python中的异步编程主要基于两个概念：协程(Coroutine) 和事件循环(Event Loop)。

  • 协程：可以理解为"轻量级线程"，它允许程序在遇到IO操作时主动挂起，去执行其他任务，等IO操作完成后再回来继续执行。
  • 事件循环：是异步程序的"大脑"，它负责管理所有的协程任务，调度它们的执行顺序。

2.2 aiohttp工作流程

aiohttp是Python中最流行的异步HTTP客户端/服务器框架，它基于asyncio实现。下面这张图清晰地展示了aiohttp异步爬虫的工作流程：

是

否

否

是

启动事件循环

创建多个协程任务

任务1: 发送请求

任务2: 发送请求

任务3: 发送请求

等待响应?

挂起当前任务, 执行其他任务

解析响应数据

任务完成

所有任务完成?

关闭事件循环

从图中可以看出，当某个任务在等待网络响应时，事件循环会立即切换到其他任务继续执行，不会有任何空闲时间。这就是异步爬虫速度快的核心秘密。

三、从同步到异步：第一个aiohttp爬虫

我们先写一个简单的同步爬虫，然后一步步改造成异步版本，让你直观地看到两者的区别。

3.1 同步爬虫示例

import requests
import time

def fetch_url(url):
    response = requests.get(url)
    return response.status_code

def main():
    urls = [f"https://httpbin.org/get?page={i}" for i in range(10)]
    
    start_time = time.time()
    
    for url in urls:
        status = fetch_url(url)
        print(f"URL: {url}, Status: {status}")
    
    end_time = time.time()
    print(f"同步爬虫耗时: {end_time - start_time:.2f}秒")

if __name__ == "__main__":
    main()

运行结果：

URL: https://httpbin.org/get?page=0, Status: 200
...
URL: https://httpbin.org/get?page=9, Status: 200
同步爬虫耗时: 3.21秒

3.2 异步爬虫改造

现在我们用aiohttp来改写这个爬虫：

import aiohttp
import asyncio
import time

async def fetch_url(session, url):
    async with session.get(url) as response:
        return response.status

async def main():
    urls = [f"https://httpbin.org/get?page={i}" for i in range(10)]
    
    start_time = time.time()
    
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        
        for url, status in zip(urls, results):
            print(f"URL: {url}, Status: {status}")
    
    end_time = time.time()
    print(f"异步爬虫耗时: {end_time - start_time:.2f}秒")

if __name__ == "__main__":
    asyncio.run(main())

运行结果：

URL: https://httpbin.org/get?page=0, Status: 200
...
URL: https://httpbin.org/get?page=9, Status: 200
异步爬虫耗时: 0.45秒

仅仅10个请求，异步版本就比同步版本快了7倍多！如果是100个、1000个请求，这个差距会更加明显。

四、生产级异步爬虫进阶

上面的例子只是入门，在实际生产环境中，我们还需要考虑很多问题：并发控制、异常处理、重试机制、超时控制等等。

4.1 并发控制：避免被封IP

很多新手在使用异步爬虫时，会一次性创建成百上千个协程任务，结果很快就被网站封了IP。这是因为并发请求数太高，给服务器造成了过大的压力。

解决方法是使用信号量(Semaphore) 来限制最大并发数：

import aiohttp
import asyncio
import time

# 限制最大并发数为10
semaphore = asyncio.Semaphore(10)

async def fetch_url(session, url):
    async with semaphore:  # 在这里加上信号量控制
        try:
            async with session.get(url, timeout=10) as response:
                return await response.text()
        except Exception as e:
            print(f"请求失败: {url}, 错误: {e}")
            return None

async def main():
    urls = [f"https://httpbin.org/get?page={i}" for i in range(100)]
    
    start_time = time.time()
    
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        
        success_count = sum(1 for result in results if result is not None)
        print(f"成功请求: {success_count}/{len(urls)}")
    
    end_time = time.time()
    print(f"总耗时: {end_time - start_time:.2f}秒")

if __name__ == "__main__":
    asyncio.run(main())

最佳实践：根据目标网站的反爬强度，将最大并发数设置在5-20之间。如果是比较友好的网站，可以适当提高到30-50。

4.2 异常处理与重试机制

网络请求是不可靠的，超时、连接失败、500错误等问题随时可能发生。一个健壮的爬虫必须有完善的异常处理和重试机制。

我们可以使用tenacity库来实现优雅的重试：

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),  # 最多重试3次
    wait=wait_exponential(multiplier=1, min=2, max=10)  # 指数退避策略
)
async def fetch_url(session, url):
    async with semaphore:
        async with session.get(url, timeout=10) as response:
            response.raise_for_status()  # 抛出HTTP状态码异常
            return await response.text()

指数退避策略是指：第一次重试等待2秒，第二次等待4秒，第三次等待8秒，以此类推。这样可以避免在服务器繁忙时加重它的负担。

4.3 连接池优化

aiohttp的ClientSession内部维护了一个连接池，默认情况下，连接池的最大连接数是100。如果你的并发数超过了这个值，就会有任务等待连接释放，影响性能。

我们可以在创建ClientSession时手动调整连接池大小：

connector = aiohttp.TCPConnector(limit=200)  # 最大连接数设置为200
async with aiohttp.ClientSession(connector=connector) as session:
    # 你的爬虫逻辑
    pass

注意：连接池大小应该大于等于你的最大并发数，否则会成为性能瓶颈。

4.4 完整的生产级爬虫框架

下面是一个我在实际项目中使用的异步爬虫框架，包含了所有生产级必备的功能：

import aiohttp
import asyncio
import time
from tenacity import retry, stop_after_attempt, wait_exponential
from fake_useragent import UserAgent

class AsyncCrawler:
    def __init__(self, max_concurrent=10, max_retries=3, timeout=10):
        self.max_concurrent = max_concurrent
        self.max_retries = max_retries
        self.timeout = timeout
        self.semaphore = asyncio.Semaphore(max_concurrent)
        self.ua = UserAgent()
        
    def get_headers(self):
        return {
            "User-Agent": self.ua.random,
            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
            "Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
            "Accept-Encoding": "gzip, deflate",
            "Connection": "keep-alive"
        }
    
    @retry(
        stop=stop_after_attempt(3),
        wait=wait_exponential(multiplier=1, min=2, max=10)
    )
    async def fetch(self, session, url):
        async with self.semaphore:
            try:
                async with session.get(
                    url, 
                    headers=self.get_headers(),
                    timeout=self.timeout
                ) as response:
                    response.raise_for_status()
                    return await response.text()
            except aiohttp.ClientError as e:
                print(f"客户端错误: {url}, {e}")
                raise
            except asyncio.TimeoutError:
                print(f"请求超时: {url}")
                raise
            except Exception as e:
                print(f"未知错误: {url}, {e}")
                raise
    
    async def parse(self, html, url):
        """解析页面数据，根据实际需求重写这个方法"""
        return {
            "url": url,
            "title": html.split("<title>")[1].split("</title>")[0] if "<title>" in html else "无标题"
        }
    
    async def process_url(self, session, url):
        html = await self.fetch(session, url)
        if html:
            return await self.parse(html, url)
        return None
    
    async def run(self, urls):
        start_time = time.time()
        
        connector = aiohttp.TCPConnector(limit=self.max_concurrent * 2)
        async with aiohttp.ClientSession(connector=connector) as session:
            tasks = [self.process_url(session, url) for url in urls]
            results = await asyncio.gather(*tasks, return_exceptions=True)
            
            # 过滤掉异常和None
            valid_results = []
            for result in results:
                if not isinstance(result, Exception) and result is not None:
                    valid_results.append(result)
            
            end_time = time.time()
            print(f"爬取完成！成功: {len(valid_results)}/{len(urls)}")
            print(f"总耗时: {end_time - start_time:.2f}秒")
            
            return valid_results

# 使用示例
if __name__ == "__main__":
    crawler = AsyncCrawler(max_concurrent=15)
    urls = [f"https://httpbin.org/get?page={i}" for i in range(100)]
    results = asyncio.run(crawler.run(urls))
    
    # 打印前5个结果
    for result in results[:5]:
        print(result)

这个框架具有以下特点：

  • 可配置的最大并发数
  • 自动重试机制（指数退避）
  • 随机User-Agent
  • 完善的异常处理
  • 连接池优化
  • 易于扩展的解析方法

五、性能对比：同步vs异步

为了让大家更直观地看到异步爬虫的性能优势，我做了一个对比测试。测试环境：Python 3.10，网络延迟约100ms。

爬取数量 同步爬虫(requests) 异步爬虫(aiohttp) 速度提升倍数
10 3.21秒 0.45秒 7.1倍
50 15.67秒 0.98秒 16.0倍
100 31.24秒 1.52秒 20.6倍
500 156.89秒 6.73秒 23.3倍
1000 312.56秒 12.87秒 24.3倍

从测试数据可以看出：

  • 随着爬取数量的增加，异步爬虫的速度优势越来越明显
  • 当爬取数量达到1000时，异步爬虫比同步爬虫快了24倍多
  • 同步爬虫的耗时基本与爬取数量成正比，而异步爬虫的耗时增长要平缓得多

六、常见坑点与解决方案

6.1 不要在异步代码中使用同步IO操作

这是新手最容易犯的错误。如果你在异步函数中使用了requests.get()、time.sleep()等同步IO操作，会阻塞整个事件循环，导致异步爬虫变得和同步爬虫一样慢，甚至更慢。

错误示例：

async def fetch_url(session, url):
    # 错误！使用了同步的requests
    response = requests.get(url)
    return response.text

正确做法：

  • 网络请求使用aiohttp
  • 延时操作使用asyncio.sleep()
  • 文件操作使用aiofiles
  • 数据库操作使用对应的异步驱动（如aiomysql、aioredis）

6.2 不要创建太多ClientSession

很多新手会在每个请求中都创建一个新的ClientSession，这是非常低效的。ClientSession是一个重量级对象，内部维护了连接池、cookie等状态。

最佳实践：整个爬虫程序只创建一个ClientSession，在所有请求中共享它。

6.3 注意内存使用

当你爬取大量页面时，所有的响应数据都会保存在内存中，可能会导致内存溢出。

解决方案：

  • 边爬取边处理，不要把所有结果都存在列表里
  • 使用asyncio.as_completed()逐个处理完成的任务
  • 对于大文件下载，使用流式传输
# 使用as_completed逐个处理任务
tasks = [self.process_url(session, url) for url in urls]
for task in asyncio.as_completed(tasks):
    result = await task
    # 立即处理结果，比如写入文件或数据库
    self.save_result(result)

七、总结

aiohttp异步爬虫是提升爬取速度的利器，它通过充分利用CPU的空闲时间，让我们在相同的时间内完成更多的工作。

在这篇文章中，我们从原理到实战，全面讲解了aiohttp异步爬虫的开发技巧：

  1. 理解了异步爬虫的核心原理：协程与事件循环
  2. 学会了如何将同步爬虫改造成异步爬虫
  3. 掌握了生产级必备的并发控制、异常处理、重试机制
  4. 看到了同步与异步爬虫的真实性能对比
  5. 了解了常见的坑点与解决方案

最后要提醒大家的是：速度不是唯一的追求。在使用异步爬虫时，一定要遵守网站的robots协议，控制好爬取频率，不要给服务器造成过大的压力。做一个有道德的爬虫开发者。

👉 点击我的头像进入主页，关注专栏第一时间收到更新提醒，有问题评论区交流，看到都会回。

# 爬虫 # python
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

扣子（Coze）漫画视频生成完整解析

扣子漫画视频是的流水线式自动生成，从文字主题到完整成片，全程由 LLM、图像、视频、语音模型协同完成，本质是把传统漫剧制作的全部自动化。下面从完整解析。

avatar AtomGit开源社区

智能的底层规律——从数据到算法的必然进化趋势

先抛出两个现象的结论，短视频的兴起完美契合了数据极致压缩的趋势。意识是数据的极致压缩与演化。如果我们将“数据”理解为原始的经验、刺激或记录，而“算法”理解为可执行、可泛化的规则或模型，那么从生物进化和AI发展的双重视角来看，——但这里的“必然”需要放在适应性系统与信息压缩的规律下来理解。

avatar AtomGit开源社区
cover

技术选型观察__数字孪生应用构建：零代码工具与专业开发套件的适配边界

avatar AtomGit开源社区