locust多进程实现分布式压测遇到的问题

多进程分布式的实现:

locust分布式时，需借助命令locust 一个一个启动worker，在使用中有点繁琐，
下面借助于多进程，按既定worker数量，一键启动；


from locust import FastHttpUser, task, User, events, HttpUser



#class WebsiteUser(FastHttpUser): 错误的使用!!!
class WebsiteUser(HttpUser):  #正确的使用
    tasks = [TaskSet]
    host = "https://www.baidu.com"
    wait_time = between(0, 0)

def processFun(cmd):
    os.system(cmd)


def start_by_process(tst_locust_file, slave_num, master_host='127.0.0.1', locust_web_port=8090, no_web=False,
                     user_num=10, user_rate=1, result_log='result.log', run_log='run.log'):
    p_lst = []
    if no_web:
        slave_cmd = f"locust -f {tst_locust_file}  --worker --master-host={master_host}"
        master_cmd = f"locust -f {tst_locust_file} --headless -u {user_num} -r {user_rate} --master"
    else:
        slave_cmd = f"locust -f {tst_locust_file}  --worker --master-host={master_host}"
        master_cmd = f"locust -f {tst_locust_file} --web-host {master_host} --web-port {locust_web_port} --master"
    master_cmd += f' --logfile {result_log} --loglevel INFO 1>{run_log} 2>&1'
    # 启动master
    process_master = multiprocessing.Process(target=processFun, args=(master_cmd,))
    process_master.start()
    p_lst.append(process_master)
    # 启动 worker
    for index_num in range(slave_num):
        process = multiprocessing.Process(target=processFun, args=(slave_cmd,))
        process.start()
        p_lst.append(process)

    # 阻塞等待
    for process in p_lst:
        process.join()
        
        
if __name__ == "__main__":
    tst_locust_path = 'wms/wms_test'
    slave_num = 3  # 计划所启动worker数量, 不可超过运行机的CPU数量
    master_host = '127.0.0.1'
    master_host = '192.168.1.102'
    locust_web_port = 8099  # locust web页面挂载端口
    no_web = False
    tst_locust_file = os.path.basename(__file__)  # 本脚本名
    os.chdir(os.getcwd().replace(tst_locust_path.replace('/', os.sep), ''))
    tst_locust_file = f'{tst_locust_path}/{tst_locust_file}'
    start_by_process(tst_locust_file, slave_num, master_host, locust_web_port, no_web=no_web)

问题:

HttpUser和FastHttpUser介绍:

在Locust中，HttpUser 和 FastHttpUser 是两种不同的用户行为模拟类，它们分别用于模拟不同的HTTP客户端行为。以下是这两种类的主要区别：

HttpUser

HttpUser 是Locust的基本HTTP用户模拟类，它使用requests库来发送HTTP请求。
HttpUser 支持多线程或多进程模式，具体取决于你的配置。
它提供了丰富的功能和灵活性，包括支持重试、会话管理、以及使用requests库的所有特性。
由于requests库本身是同步的，因此在高并发场景下，HttpUser可能会导致较高的CPU使用率，尤其是当请求之间没有足够的等待时间时。
HttpUser适用于大多数HTTP负载测试场景，特别是那些对复杂性和灵活性有较高要求的测试。

FastHttpUser

FastHttpUser 是一个较新的类，它使用httpx库来发送HTTP请求，这是一个异步的HTTP客户端库。
FastHttpUser 提供了更高的性能和更低的CPU使用率，因为它使用了异步I/O，可以在等待网络响应时执行其他任务。
它特别适合于高并发的场景，可以显著减少CPU使用率，尤其是在大量并发用户的情况下。
FastHttpUser 相对于HttpUser来说，可能不支持requests库的所有高级特性，但在大多数情况下，基本的功能如GET、POST请求等都是支持的。
如果你的目标是进行大规模并发测试，同时保持较低的CPU使用率，FastHttpUser是一个很好的选择。

总结

如果你的测试场景需要高度定制化的请求设置或者你已经在使用requests库的高级功能，那么HttpUser可能更适合你。
如果你希望在高并发场景下减少CPU使用率，并且能够接受一定的功能限制，那么FastHttpUser是一个更好的选择。

示例

以下是使用HttpUser和FastHttpUser的简单示例：

HttpUser 示例

from locust import HttpUser, task, between

class MyHttpUser(HttpUser):
    wait_time = between(1, 5)

    @task
    def my_task(self):
        self.client.get("/some_endpoint")

FastHttpUser 示例

from locust import FastHttpUser, task, between

class MyFastHttpUser(FastHttpUser):
    wait_time = between(1, 5)

    @task
    def my_task(self):
        self.client.get("/some_endpoint")

请注意，在使用FastHttpUser时，你需要确保你的Locust版本支持该类。如果不确定，可以检查你的Locust版本或者查阅官方文档。

原因分析:

异步I/O与多进程的交互：

FastHttpUser使用httpx库来进行异步HTTP请求，而httpx是基于trio或anyio的异步I/O库。
在多进程环境下，每个进程都有自己的事件循环，这可能导致每个进程中的异步I/O操作无法有效地与其他进程协调，从而增加了CPU的负担。

多进程与异步I/O的兼容性：

多进程模式下，每个进程都有独立的内存空间和事件循环，这可能意味着每个进程都在单独运行其事件循环，而不是共享一个全局的事件循环。这种情况下，每个进程都在尝试同时执行大量的异步任务，可能会导致CPU使用率上升。

事件循环的调度：

在FastHttpUser中，每个进程可能有自己的事件循环，而在多进程模式下，这些事件循环可能没有被有效地调度，导致CPU使用率增加。
httpx的异步特性通常在单进程中表现更好，因为它可以充分利用事件驱动模型的优势，但在多进程环境下，每个进程都需要维护自己的事件循环，这可能会导致额外的开销。

并发模型的不匹配：

FastHttpUser的设计初衷是为了利用异步I/O的优势来提高性能，特别是在高并发场景下。然而，在多进程模式下，这种优势可能会因为进程间的隔离和通信开销而被抵消。

DuKe渡客