一、Locust负载测试并发上不去的常见坑

做接口性能测试的朋友,大概率都用过Locust。它的优势是用Python写测试脚本,简单好上手,还能模拟成千上万的用户并发。但很多人都会遇到一个诡异的问题:明明设置了要启动1000个并发用户,最后实际能跑起来的可能只有几百,甚至更少。最常见的原因,就是协程阻塞了——而这背后的核心,是Locust底层用的gevent库的调度逻辑出了问题。

先给大家说个真实的踩坑场景:之前帮一个电商团队做大促前的性能测试,他们用Locust模拟用户下单流程,脚本里写了登录、加购物车、提交订单三个接口,每个接口都用了requests库发请求。设置的是2000个并发用户,启动后监控服务器负载、网络带宽都没到瓶颈,Locust控制台却显示实际活跃用户只有300多,并发上不去。后来查了半天,才发现是requests库的同步请求把gevent的协程给堵死了。

二、拆解gevent的调度逻辑:协程为啥会“假死”?

要解决协程阻塞的问题,首先得搞懂gevent是怎么工作的。很多人以为gevent的协程和Python原生的asyncio协程差不多,其实完全不是一回事,它的核心是“猴子补丁”(monkey patch)和事件循环调度。

2.1 gevent的核心调度逻辑

gevent的底层原理是:把Python标准库里的同步IO操作(比如网络请求、文件读写、睡眠),通过猴子补丁替换成自己实现的异步版本。当一个协程执行到被替换的同步操作时,不会像原生同步代码那样把整个线程堵死,而是主动让出CPU,让gevent的事件循环去调度其他可以运行的协程。等IO操作完成后,这个协程再被唤醒继续执行。

举个简单的例子,假设你有两个协程:协程A要发一个请求,需要等1秒才能收到响应;协程B要做一些计算,不需要等IO。正常的同步代码会先执行协程A,等1秒收到响应后才会执行协程B,总耗时1秒多;gevent的逻辑是,协程A发完请求后主动让出CPU,gevent马上调度协程B执行,等1秒后协程A的响应到了,再调度协程A继续,总耗时还是1秒多,但两个协程的工作是“穿插”进行的,不会互相等待。

2.2 协程阻塞的核心原因:没打猴子补丁

那为啥会出现协程阻塞?最常见的原因就是——没给gevent打猴子补丁。

很多人写Locust脚本的时候,会直接导入requests库发请求,然后启动Locust,却忘了打猴子补丁。这时候requests库还是用的Python原生的同步网络操作,当一个协程发请求的时候,整个gevent的事件循环就被堵死了,所有其他协程都没法执行,只能等这个请求响应完。相当于你本来想让1000个协程并行工作,结果变成了串行,并发自然上不去。

给大家看一个错误的脚本示例,技术栈统一为Python 3.9 + Locust 2.15 + gevent 21.12:

# 错误示例:没打猴子补丁的Locust脚本
from locust import HttpUser, task, between

# 错误:直接导入requests,没打猴子补丁
import requests

class TestUser(HttpUser):
    wait_time = between(1, 3)

    @task
    def test_order(self):
        # 发登录请求
        login_url = "https://api.example.com/login"
        login_data = {"username": "test", "password": "123456"}
        # 用requests发同步请求,没打补丁的话会阻塞整个事件循环
        resp = requests.post(login_url, json=login_data)
        # 发加购物车请求
        cart_url = "https://api.example.com/cart/add"
        cart_data = {"sku_id": "123", "count": 1}
        resp = requests.post(cart_url, json=cart_data)
        # 发提交订单请求
        order_url = "https://api.example.com/order/create"
        order_data = {"sku_id": "123", "count": 1}
        resp = requests.post(order_url, json=order_data)

这个脚本跑起来,你会发现即使设置1000个用户,实际活跃用户也只有很少,因为每个协程发请求的时候都把事件循环堵死了。

2.3 其他导致阻塞的场景

除了没打猴子补丁,还有几种场景会导致gevent协程阻塞:

  1. 写了CPU密集型代码:比如循环做复杂的计算、加密解密,gevent的协程是单线程调度的,CPU密集型代码会一直占着CPU,不会主动让出,导致其他协程没法执行。
  2. 用了不支持gevent的第三方库:比如有些库自己实现了同步的网络操作,没有用猴子补丁替换,也会导致阻塞。
  3. 猴子补丁打错了顺序:比如先导入了requests,再打猴子补丁,这时候requests已经加载了原生的同步代码,补丁就失效了。

三、gevent调度的调优方案:让协程跑满并发

针对上面的问题,我们可以从打补丁、替换IO操作、优化代码三个方面来调优,解决协程阻塞的问题。

3.1 第一步:正确打猴子补丁

打猴子补丁的核心是“先打补丁,再导入其他库”。也就是说,你要在脚本的最开头,先给gevent打补丁,再导入requests、locust这些库。

正确的补丁写法是用gevent.monkey的patch_all()方法,这个方法会把Python标准库里所有的同步IO操作都替换成gevent的异步版本。

给大家看正确的脚本示例:

# 正确示例:先打猴子补丁
from gevent import monkey
# 打所有标准库的同步IO补丁,必须放在最开头
monkey.patch_all()

# 补丁打完后再导入其他库
from locust import HttpUser, task, between
import requests

class TestUser(HttpUser):
    wait_time = between(1, 3)

    @task
    def test_order(self):
        # 发登录请求
        login_url = "https://api.example.com/login"
        login_data = {"username": "test", "password": "123456"}
        # 现在requests已经被补丁替换成异步版本,不会阻塞事件循环
        resp = requests.post(login_url, json=login_data)
        # 发加购物车请求
        cart_url = "https://api.example.com/cart/add"
        cart_data = {"sku_id": "123", "count": 1}
        resp = requests.post(cart_url, json=cart_data)
        # 发提交订单请求
        order_url = "https://api.example.com/order/create"
        order_data = {"sku_id": "123", "count": 1}
        resp = requests.post(order_url, json=order_data)

3.2 第二步:替换不支持gevent的IO操作

如果遇到有些第三方库不支持gevent,没法通过补丁替换的,我们可以把它的同步IO操作放到gevent的线程池里执行,这样不会阻塞主事件循环。

比如有些团队用的内部加密库,是同步的,每次加密需要100毫秒,会导致协程阻塞。我们可以用gevent的threadpool来处理:

# 示例:用gevent线程池处理同步加密操作
from gevent import monkey
monkey.patch_all()

from locust import HttpUser, task, between
import requests
# 导入内部同步加密库
from internal_crypto import encrypt
# 导入gevent线程池
from gevent.threadpool import ThreadPool

# 初始化线程池,线程数可以根据需求调整,一般设为CPU核心数的2-4倍
thread_pool = ThreadPool(10)

class TestUser(HttpUser):
    wait_time = between(1, 3)

    @task
    def test_order(self):
        # 发登录请求
        login_url = "https://api.example.com/login"
        login_data = {"username": "test", "password": "123456"}
        resp = requests.post(login_url, json=login_data)
        
        # 处理加密操作:把同步的encrypt放到线程池里执行,不会阻塞主事件循环
        raw_data = "test_sku_123"
        encrypted_data = thread_pool.spawn(encrypt, raw_data).get()
        
        # 发加购物车请求
        cart_url = "https://api.example.com/cart/add"
        cart_data = {"sku_id": "123", "count": 1, "sign": encrypted_data}
        resp = requests.post(cart_url, json=cart_data)
        
        # 发提交订单请求
        order_url = "https://api.example.com/order/create"
        order_data = {"sku_id": "123", "count": 1, "sign": encrypted_data}
        resp = requests.post(order_url, json=order_data)

3.3 第三步:优化CPU密集型代码

如果脚本里有CPU密集型的代码,比如复杂的循环计算、大量的数据处理,我们可以用gevent的多进程来处理,因为gevent的协程是单线程的,没法利用多核CPU,把CPU密集型代码放到单独的进程里,就不会影响主进程的协程调度。

比如下面的示例,把复杂的计算放到子进程里:

# 示例:用gevent多进程处理CPU密集型代码
from gevent import monkey
monkey.patch_all()

from locust import HttpUser, task, between
import requests
# 导入gevent多进程
from gevent.process import Process
from multiprocessing import Queue

# 定义CPU密集型的计算函数
def heavy_calc(input_data, result_queue):
    # 模拟复杂计算,比如循环100万次的运算
    result = 0
    for i in range(1000000):
        result += i * input_data
    # 把计算结果放到队列里
    result_queue.put(result)

class TestUser(HttpUser):
    wait_time = between(1, 3)

    @task
    def test_order(self):
        # 发登录请求
        login_url = "https://api.example.com/login"
        login_data = {"username": "test", "password": "123456"}
        resp = requests.post(login_url, json=login_data)
        
        # 处理CPU密集型计算:放到子进程里执行
        result_queue = Queue()
        calc_process = Process(target=heavy_calc, args=(10, result_queue))
        calc_process.start()
        # 等待子进程计算完成,这里用gevent的join,不会阻塞主事件循环
        calc_process.join()
        # 获取计算结果
        calc_result = result_queue.get()
        
        # 发加购物车请求
        cart_url = "https://api.example.com/cart/add"
        cart_data = {"sku_id": "123", "count": 1, "calc_result": calc_result}
        resp = requests.post(cart_url, json=cart_data)
        
        # 发提交订单请求
        order_url = "https://api.example.com/order/create"
        order_data = {"sku_id": "123", "count": 1, "calc_result": calc_result}
        resp = requests.post(order_url, json=order_data)

四、应用场景、优缺点与注意事项

4.1 应用场景

gevent的调度调优方案主要适用于以下场景:

  1. 用Locust做接口性能测试,并发上不去的场景;
  2. 基于gevent开发的Python服务,出现协程阻塞、性能瓶颈的场景;
  3. 其他需要高并发的Python应用,比如爬虫、即时通讯服务等。

4.2 技术优缺点

优点

  1. 调优成本低:只需要调整补丁顺序、替换IO操作,不需要重构整个代码;
  2. 性能提升明显:正确调优后,协程不会阻塞,并发可以提升数倍甚至数十倍;
  3. 兼容性好:gevent的补丁和线程池、多进程方案,对现有代码的改动很小。

缺点

  1. 猴子补丁的不确定性:补丁可能会和某些第三方库冲突,导致意外的错误;
  2. 调试难度大:协程阻塞的问题很难定位,需要对gevent的调度逻辑有深入的理解;
  3. 单线程限制:gevent的协程是单线程调度的,没法利用多核CPU,不适合纯CPU密集型的应用。

4.3 注意事项

  1. 补丁顺序:必须先打猴子补丁,再导入其他库,否则补丁会失效;
  2. 避免CPU密集型代码:尽量把CPU密集型代码放到线程池或多进程里执行;
  3. 监控协程状态:可以用gevent的监控工具,比如gevent.monitor,来查看协程的运行状态,及时发现阻塞的协程;
  4. 不要过度依赖补丁:对于不支持gevent的第三方库,尽量替换成支持gevent的版本,或者用线程池处理。

五、文章总结

Locust负载测试中协程阻塞导致并发上不去的问题,本质上是gevent的调度逻辑出了问题,核心原因是同步IO操作没有被替换成gevent的异步版本,导致协程阻塞整个事件循环。

解决这个问题的核心思路是:先正确打猴子补丁,替换标准库的同步IO操作;对于不支持gevent的第三方库,用线程池处理;对于CPU密集型代码,用多进程处理。

通过这些调优方案,我们可以让gevent的协程正常调度,充分利用CPU和网络资源,提升并发能力。