终面压轴：如何用`asyncio`解决高并发下`requests`阻塞问题？

本文链接：https://blog.youkuaiyun.com/itAred/article/details/147948395

场景设定：终面压轴问题

在终面的最后5分钟，面试官突然抛出了一个技术深度的问题，直接考验候选人的异步编程能力和对高并发场景的理解。

角色扮演：面试官提问

面试官：小兰，我们今天的终面接近尾声了。我最后想问一个稍微复杂一点的问题。假设你在开发一个需要频繁调用API的应用，使用传统的requests库时发现高并发场景下性能不佳，出现了明显的阻塞问题。现在，我想让你用asyncio来解决这个问题，并设计一个完整的解决方案。同时，你还需要对比aiohttp和requests的性能差异，并给出一些优化建议。时间有限，你可以快速组织一下思路。

角色扮演：小兰的回答

小兰：（皱眉思考了一会儿，然后露出自信的微笑）啊！这个问题太棒了！让我来掰扯一下……嗯……首先，requests库在高并发场景下会遇到阻塞问题，因为它本质上是同步的。每次requests.get()或者requests.post()的时候，程序都会停下来等待响应返回，这就导致了效率低下，尤其是当我们同时调用多个API时。

为了解决这个问题，我们可以用asyncio结合aiohttp来实现异步请求。aiohttp是专门为异步编程设计的HTTP客户端库，它可以很好地配合asyncio使用。相比之下，requests是同步的，每次只能处理一个请求，而aiohttp可以同时处理多个请求，大大提升了并发性能。

设计解决方案

1. 使用`asyncio`和`aiohttp`实现异步请求

我们可以用asyncio的gather方法来并发执行多个异步请求。具体步骤如下：

导入aiohttp库。
定义一个异步函数，使用aiohttp的ClientSession发起异步请求。
使用asyncio.gather并发执行多个请求。
最后打印结果。

2. 对比`aiohttp`和`requests`的性能

为了直观地看到性能差异，我们可以编写一个简单的测试脚本，分别用requests和aiohttp发起多次请求，并记录执行时间。

代码示例

1. 使用`aiohttp`的异步请求

import asyncio
import aiohttp

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

async def main():
    urls = [
        "https://httpbin.org/get",
        "https://httpbin.org/get",
        "https://httpbin.org/get",
        # 可以添加更多URL
    ]

    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        for result in results:
            print(result)

# 运行异步主函数
asyncio.run(main())

2. 使用`requests`的同步请求

import requests
import time

def fetch_url(url):
    return requests.get(url).text

def main():
    urls = [
        "https://httpbin.org/get",
        "https://httpbin.org/get",
        "https://httpbin.org/get",
        # 可以添加更多URL
    ]

    start_time = time.time()
    results = [fetch_url(url) for url in urls]
    end_time = time.time()

    for result in results:
        print(result)

    print(f"Total time using requests: {end_time - start_time} seconds")

main()

3. 性能对比

通过运行上述代码，我们可以直观地看到：

requests会逐个发送请求，每次都要等待上一个请求完成，因此耗时较长。
aiohttp可以并发发送多个请求，显著缩短了总执行时间。

性能优化建议

使用连接池： aiohttp支持连接池，可以通过ClientSession的connector参数来控制连接数，避免频繁创建和销毁连接。
```
async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(limit=10)) as session:
    # 使用session发起请求
```
批量请求：如果API支持批量请求，尽量合并多个请求为一个，减少网络开销。
缓存结果：对于频繁访问的API，可以使用缓存机制（如aiocache）来减少重复请求。

监控和限流：使用asyncio的Semaphore来限制并发请求数，防止服务器压力过大。

import asyncio
from aiohttp import ClientSession
from asyncio import Semaphore

async def fetch_url(session, url, semaphore):
    async with semaphore:
        async with session.get(url) as response:
            return await response.text()

async def main():
    urls = [
        "https://httpbin.org/get",
        "https://httpbin.org/get",
        "https://httpbin.org/get",
    ]
    semaphore = Semaphore(5)  # 限制并发请求数为5
    async with ClientSession() as session:
        tasks = [fetch_url(session, url, semaphore) for url in urls]
        results = await asyncio.gather(*tasks)
        for result in results:
            print(result)

asyncio.run(main())

总结

通过使用asyncio和aiohttp，我们可以轻松解决requests在高并发场景下的阻塞问题。aiohttp的异步特性使得它在处理大量并发请求时具有显著优势，尤其是在需要频繁调用API的应用中，性能提升非常明显。

面试官的反应

面试官：（点头微笑）小兰，你的回答非常全面！不仅给出了代码示例，还提出了性能优化的建议，这说明你对异步编程和高并发场景有比较深入的理解。不过，如果你能在实际项目中积累更多经验，相信会更有助于提升你的能力。

小兰：谢谢您的鼓励！我也意识到自己还有很多需要学习的地方，回去一定多实践，争取下次能更完美地回答类似问题！

（面试官微笑点头，结束了这次终面）

正确解析

requests的局限性：
- 同步阻塞：每次requests.get()都会阻塞主线程，直到响应返回。
- 不适合高并发场景。
aiohttp的优势：
- 异步非阻塞：支持多任务并发执行，适合高并发场景。
- 连接池管理：减少连接创建和销毁的开销。
- 整合asyncio生态：与asyncio无缝结合。
性能优化点：
- 限制并发请求数：避免服务器过载。
- 使用连接池：复用连接，减少网络开销。
- 批量请求：合并小请求为大请求，减少HTTP请求次数。
- 缓存机制：避免重复请求相同数据。