1定时器执行顺序：
21. 配置元件
32. 前置处理器
43. 定时器（按在测试计划树中的顺序）
54. 采样器
65. 后置处理器
76. 断言
87. 监听器

1右键点击线程组 → Add → Timer → Constant Timer

1名称: 固定定时器
2线程延迟（毫秒）: 1000

1线程延迟（毫秒）: 1000

1测试计划结构示例：
2测试计划
3├── 线程组（10线程，循环10次）
4│   ├── 固定定时器（1000毫秒）
5│   ├── HTTP请求（登录）
6│   ├── HTTP请求（浏览首页）
7│   └── HTTP请求（查看商品）

1右键点击线程组 → Add → Timer → Gaussian Random Timer

1名称: 高斯随机定时器
2偏差（毫秒）: 500
3常量延迟（毫秒）: 1000

1偏差（毫秒）: 500

1常量延迟（毫秒）: 1000

1总延迟 = 常量延迟 + 高斯随机数 * 偏差

1常量延迟: 1000毫秒
2偏差: 500毫秒
3
4延迟范围: 1000 ± 3 * 500 = -500 ~ 2500毫秒
5实际延迟: 0 ~ 2500毫秒（负延迟取0）

 1测试计划结构示例：
 2测试计划
 3├── 线程组（100线程，循环10次）
 4│   ├── 高斯随机定时器
 5│   │   偏差: 500
 6│   │   常量延迟: 1000
 7│   ├── HTTP请求（登录）
 8│   ├── HTTP请求（浏览商品）
 9│   ├── HTTP请求（添加购物车）
10│   └── HTTP请求（下单）

1右键点击线程组 → Add → Timer → Uniform Random Timer

1名称: 均匀随机定时器
2随机延迟最大值（毫秒）: 2000
3常量延迟（毫秒）: 1000

1随机延迟最大值（毫秒）: 2000

1常量延迟（毫秒）: 1000

1总延迟 = 常量延迟 + 随机数(0 ~ 随机延迟最大值)

1常量延迟: 1000毫秒
2随机延迟最大值: 2000毫秒
3
4延迟范围: 1000 ~ 3000毫秒

1测试计划结构示例：
2测试计划
3├── 线程组（50线程，循环10次）
4│   ├── 均匀随机定时器
5│   │   随机延迟最大值: 2000
6│   │   常量延迟: 1000
7│   └── HTTP请求（浏览页面）

1右键点击线程组 → Add → Timer → Constant Throughput Timer

1名称: 吞吐量定时器
2目标吞吐量（样本/分钟）: 600
3计算吞吐量的基础: 所有活跃线程

1目标吞吐量（样本/分钟）: 600

1目标吞吐量（样本/秒）= 目标吞吐量（样本/分钟）/ 60
2600样本/分钟 = 10样本/秒

1计算吞吐量的基础: 所有活跃线程

1测试计划结构示例：
2测试计划
3├── 线程组（100线程，循环Forever）
4│   ├── 吞吐量定时器
5│   │   目标吞吐量: 600（10样本/秒）
6│   │   计算基础: 所有活跃线程
7│   └── HTTP请求（测试接口）

1右键点击线程组 → Add → Timer → Synchronizing Timer

1名称: 同步定时器
2模拟用户组数量: 10
3超时时间（毫秒）: 0

1模拟用户组数量: 10

1超时时间（毫秒）: 0

11. 线程到达同步定时器时暂停
22. 当暂停的线程数达到"模拟用户组数量"时，同时释放所有线程
33. 如果等待时间超过"超时时间"，释放已暂停的线程

1测试计划结构示例：
2测试计划
3├── 线程组（100线程，循环10次）
4│   ├── 同步定时器
5│   │   模拟用户组数量: 10
6│   │   超时时间: 0
7│   └── HTTP请求（秒杀接口）

1右键点击线程组 → Add → Timer → JSR223 Timer

 1名称: JSR223定时器
 2脚本语言: groovy
 3脚本:
 4    // 计算延迟时间
 5    def baseDelay = 1000
 6    def randomDelay = new Random().nextInt(2000)
 7    def totalDelay = baseDelay + randomDelay
 8    
 9    // 设置延迟
10    return totalDelay

1脚本语言: groovy

1// 脚本内容

 1// 根据响应时间动态调整延迟
 2def responseTime = prev?.getTime() ?: 0
 3
 4// 如果响应时间超过2秒，增加延迟
 5if (responseTime > 2000) {
 6    return 3000 + new Random().nextInt(2000)
 7}
 8
 9// 正常延迟
10return 1000 + new Random().nextInt(1000)

 1// 获取当前时间
 2def hour = new Date().getHours()
 3
 4// 高峰期（9-12点，14-18点）使用较短延迟
 5if ((hour >= 9 && hour <= 12) || (hour >= 14 && hour <= 18)) {
 6    return 500 + new Random().nextInt(500)
 7}
 8
 9// 非高峰期使用较长延迟
10return 2000 + new Random().nextInt(2000)

1右键点击线程组 → Add → Timer → Constant Throughput Timer

1名称: 固定吞吐量定时器
2目标吞吐量（样本/分钟）: 1200
3计算吞吐量的基础: 当前线程组的所有活跃线程

1目标吞吐量（样本/分钟）: 1200

1计算吞吐量的基础: 当前线程组的所有活跃线程

1测试计划结构示例：
2测试计划
3├── 线程组（50线程，循环Forever）
4│   ├── 固定吞吐量定时器
5│   │   目标吞吐量: 1200（20样本/秒）
6│   │   计算基础: 当前线程组的所有活跃线程
7│   └── HTTP请求（测试接口）

1添加位置: 采样器级别
2作用域: 仅该采样器

1添加位置: 控制器级别
2作用域: 控制器内所有采样器

1添加位置: 线程组级别
2作用域: 线程组内所有采样器

1添加位置: 测试计划级别
2作用域: 所有线程组

1偏差: 500
2常量延迟: 1000

1方法: GET
2路径: /

1方法: GET
2路径: /products

1方法: GET
2路径: /products/${product_id}

1方法: POST
2路径: /cart/add
3参数:
4    product_id: ${product_id}
5    quantity: 1

1方法: POST
2路径: /checkout

1目标吞吐量: 600（10样本/秒）
2计算基础: 所有活跃线程

1方法: GET
2路径: /api/test

1模拟用户组数量: 1000
2超时时间: 0

1方法: POST
2路径: /api/seckill
3参数:
4    product_id: 1
5    user_id: ${__Random(1,1000000)}

 1// 获取前一个采样器的响应时间
 2def responseTime = prev?.getTime() ?: 0
 3
 4// 根据响应时间动态调整延迟
 5def delay = 1000 // 默认1秒
 6
 7if (responseTime > 3000) {
 8    // 服务器响应慢，增加思考时间
 9    delay = 3000 + new Random().nextInt(2000)
10} else if (responseTime > 1000) {
11    // 服务器响应一般，正常思考时间
12    delay = 1500 + new Random().nextInt(1000)
13} else {
14    // 服务器响应快，减少思考时间
15    delay = 500 + new Random().nextInt(500)
16}
17
18log.info("Response time: ${responseTime}ms, Delay: ${delay}ms")
19return delay

1方法: GET
2路径: /api/test