多进程分布式的实现:

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中,HttpUserFastHttpUser 是两种不同的用户行为模拟类,它们分别用于模拟不同的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是一个更好的选择。

示例

以下是使用HttpUserFastHttpUser的简单示例:

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版本或者查阅官方文档。

原因分析:

  1. 异步I/O与多进程的交互:
  • FastHttpUser使用httpx库来进行异步HTTP请求,而httpx是基于trio或anyio的异步I/O库。
  • 在多进程环境下,每个进程都有自己的事件循环,这可能导致每个进程中的异步I/O操作无法有效地与其他进程协调,从而增加了CPU的负担。
  1. 多进程与异步I/O的兼容性:
  • 多进程模式下,每个进程都有独立的内存空间和事件循环,这可能意味着每个进程都在单独运行其事件循环,而不是共享一个全局的事件循环。这种情况下,每个进程都在尝试同时执行大量的异步任务,可能会导致CPU使用率上升。
  1. 事件循环的调度:
  • 在FastHttpUser中,每个进程可能有自己的事件循环,而在多进程模式下,这些事件循环可能没有被有效地调度,导致CPU使用率增加。
  • httpx的异步特性通常在单进程中表现更好,因为它可以充分利用事件驱动模型的优势,但在多进程环境下,每个进程都需要维护自己的事件循环,这可能会导致额外的开销。
  1. 并发模型的不匹配:
  • FastHttpUser的设计初衷是为了利用异步I/O的优势来提高性能,特别是在高并发场景下。然而,在多进程模式下,这种优势可能会因为进程间的隔离和通信开销而被抵消。
07-24 22:09