Locust 2.8 任务集 TaskSet

任务集

TaskSet

TaskSet是一个任务集合，里面所有的任务都是同时进行的，没有先后顺序，支持嵌套

class MyTaskSet1(TaskSet):

    # @task
    # 加了权重只后，运行率会更均匀，可能是locust的问题吧
    @task(1)
    def task1(self):
        self.client.get('/task1')


class MyTaskSet2(TaskSet):

    # @task
    @task(1)
    def task2(self):
        self.client.get('/task1')


class Play(HttpUser):
    tasks = [MyTaskSet1, MyTaskSet2]

理论上这两个 TaskSet 执行的数量应该是一样的但是并没有，加了 task 的权重只后是均分的，可能是 locust 没有权重的情况下任务分配的问题吧

还有一个需要注意的地方，这里100用户数，是同时被两个 TaskSet 消费的，也就是说每个用户会选择其一去执行它

嵌套写法：

from locust import TaskSet, task, HttpUser, constant


class UserTask(TaskSet):
    @task
    class stay(TaskSet):
        @task
        def readBook(self):
            self.client.get('/readBook')

        @task
        def listenMusic(self):
            self.client.get('/listenMusic')
            # 退出当前任务集
            self.interrupt()

    @task
    def leave(self):
        self.client.get('/leave')


class User(HttpUser):
    tasks = [UserTask]
    wait_time = constant(2)

没有 interrupt() 方法的执行结果：

可以看到，在执行过第一轮之后，后续就不再执行 leave 了，只会运行 stay 中的任务

有 interrupt() 方法的执行结果：

在足够长的运行时间下，可以看到每个任务的执行率都是相同的

SequentialTaskSet

按顺序执行的任务集，此示例的执行顺序是 task1 -> task2 -> task3

跟 TaskSet 一样，是支持嵌套的，可以使用这个特性设计复杂的业务场景

class MyTaskSet(SequentialTaskSet):

    @task
    def task1(self):
        self.client.get('/task1')

    @task
    def task2(self):
        self.client.get('/task2')

    @task
    def task3(self):
        self.client.get('/task3')

class Play(HttpUser):
    tasks = [MyTaskSet]
    wait_time = constant(1)

执行结果：

任务分配的很均匀，而且始终保持 task1 -> task2 -> task3 这样的顺序执行

需要注意的是，我启动了100个用户，被 3 个 task 平均分配了