测试:压力测试

原创已于 2025-09-30 14:15:35 修改 · 751 阅读

26 ·

CC 4.0 BY-SA版权

文章标签：

#压力测试

于 2025-09-30 09:40:20 首次发布

测试项专栏收录该内容

3 篇文章

订阅专栏

压力测试是通过模拟高并发、高负载或极端环境，验证系统在超出正常使用场景下的性能表现、稳定性及容错能力的关键测试手段。以下是系统化的操作流程，涵盖目标设定、环境准备、工具选择、场景设计、执行监控、结果分析等核心环节，帮助你高效开展压力测试。

一、明确测试目标与需求

压力测试的核心是解决具体问题，需先明确目标（避免为压测而压测）。常见目标包括：

验证性能指标：如接口响应时间≤200ms、系统吞吐量≥1000QPS（每秒请求数）。
定位瓶颈：找出CPU/内存/数据库/网络等资源的瓶颈点。
评估稳定性：系统在持续高压（如7×24小时）下是否会出现崩溃、内存泄漏或连接池耗尽。
容灾能力验证：超负载时系统能否触发限流、降级或自动扩容。

关键输出：一份《测试需求说明书》，明确测试范围（哪些接口/模块）、核心指标（响应时间、TPS、错误率）、失败阈值（如错误率＞5%即停止测试）。

二、测试环境与数据准备

1. 环境搭建

尽量贴近生产环境：硬件配置（CPU/内存/磁盘）、网络带宽、软件版本（数据库/中间件）需与生产一致，避免环境差异导致结果失真。
隔离测试环境：压测时不能影响生产数据或线上服务（可通过影子库、Mock外部依赖实现）。
监控部署：提前在生产级监控工具（如Prometheus+Grafana、Zabbix、APM工具如SkyWalking）中配置监控指标，覆盖：
- 服务器层：CPU/内存/磁盘I/O/网络带宽使用率。
- 应用层：线程状态、GC频率、连接池（数据库/HTTP）使用情况。
- 中间件层：数据库慢查询、消息队列堆积、缓存命中率。

2. 测试数据构造

真实数据模拟：基于生产日志提取用户行为数据（如请求参数、频率分布），避免使用随机数据导致测试失真。
数据规模匹配：若生产库有1000万用户，压测时需构造至少同等量级的数据（可通过工具如sysbench、Faker或自定义脚本生成）。
数据隔离：压测数据需独立（如使用独立数据库或通过SHARDING_KEY隔离），避免污染生产数据。

三、选择压力测试工具

根据系统类型（Web/API/数据库）和团队技术栈选择工具，常见工具如下：

工具类型	工具示例	适用场景
通用压测工具	JMeter、Locust、Gatling	Web应用、HTTP/HTTPS接口、RPC接口压测；支持分布式压测（多机协同）。
数据库压测	sysbench、TPCC-MySQL	测试MySQL/PostgreSQL的QPS、TPS、锁竞争、索引效率。
消息队列压测	Kafka Producer Perf、RocketMQ Benchmark	测试消息队列的生产/消费速率、延迟、堆积能力。
云原生压测	k6、Locust（容器化部署）	适配K8s环境，支持动态扩缩容场景的压测。

示例：测试一个电商下单接口，可选择JMeter模拟1000个用户并发请求，通过CSV文件参数化用户ID、商品ID，验证接口在高并发下的响应时间和数据库连接池使用情况。

四、设计压力测试场景

场景设计需覆盖正常负载→逐步加压→极限负载→恢复验证的全链路，常见场景类型：

1. 基础场景

正常负载：模拟日常峰值流量（如电商的“上午10点”“晚上8点”流量），验证系统是否能稳定支撑。
峰值负载：模拟突发流量（如秒杀活动、大促），负载通常是日常峰值的2~5倍，验证系统弹性。

2. 高级场景

持续高压：长时间（如48小时）保持高负载，检测内存泄漏、连接池耗尽、缓存失效等问题。
浪涌测试：短时间内流量骤增骤降（如从1000QPS突增至5000QPS，再回落），验证系统容错和自动恢复能力。
依赖故障注入：模拟数据库宕机、缓存失效，观察系统是否触发降级（如返回缓存的旧数据）或熔断（拒绝请求保护核心服务）。

3. 场景设计关键动作

参数化：用动态数据（如随机用户ID、订单号）避免重复请求被缓存或限流。
关联：提取前一步响应中的动态值（如登录后的Token），作为下一步请求的参数（如下单接口需要携带Token）。
事务与断言：标记关键操作（如下单、支付）为事务，统计其成功率；设置断言（如响应状态码=200、返回字段“code”=0），自动识别失败请求。

五、执行测试与监控

1. 分阶段执行

预测试：小负载（如100QPS）验证脚本正确性（参数是否生效、断言是否触发），避免正式压测时因脚本错误浪费资源。
逐步加压：按梯度增加负载（如100→500→1000→2000QPS），每个负载稳定运行5~10分钟，观察系统指标变化（如响应时间是否线性增长、错误率是否突增）。
极限压测：找到系统瓶颈点（如响应时间突然从200ms跳到2s、错误率＞5%），记录此时的最大负载（如3000QPS）。
恢复测试：停止压测后，观察系统指标（如CPU/内存是否回落、连接池是否释放）是否在合理时间内恢复正常。

2. 实时监控与问题捕获

应用层：通过日志工具（ELK）监控是否有大量异常堆栈（如OutOfMemoryError、数据库连接超时）。
中间件：检查数据库慢查询（如超过1s的SQL）、Redis连接数是否达到上限、消息队列是否堆积。
工具层面：压测工具（如JMeter）的聚合报告需关注：
- 平均响应时间、90%分位响应时间（更反映用户体验）。
- 吞吐量（TPS/QPS）：单位时间处理的请求数。
- 错误率：失败请求数/总请求数（需＜0.1%才算稳定）。

六、结果分析与报告输出

1. 定位瓶颈点

通过“指标关联分析”定位问题根源：

CPU高：可能是应用逻辑复杂（如循环嵌套、正则匹配）、GC频繁（内存泄漏或对象创建过多）。
内存高：检查是否有未释放的资源（如数据库连接、缓存未设置过期时间）、大对象（如未分页的查询结果）。
数据库慢：查看慢查询日志，确认是否缺少索引、全表扫描或锁竞争（如行锁/表锁）。
网络延迟：检查API调用链（如APM工具），确认是否因外部服务（如第三方支付）响应慢导致整体延迟。

2. 输出测试报告

报告需包含：

测试结论：是否满足性能目标（如“在2000QPS下，响应时间≤500ms，错误率0%，满足大促要求”）。
瓶颈与优化建议：如“数据库CPU高，建议对order表的user_id字段添加索引”“应用内存泄漏，需修复XXXService中的未关闭连接”。
容量规划：给出系统最大承载能力（如“当前架构支持5000QPS，若需支撑双11需扩容3台应用服务器”）。

七、注意事项

安全第一：压测前备份生产数据，避免因测试导致数据丢失；禁止对线上环境直接压测。
渐进式加压：避免一次性高负载（如直接10万QPS）导致系统崩溃，无法定位瓶颈。
多次验证：同一场景重复测试3次以上，排除偶发因素（如垃圾回收、网络抖动）。
文档沉淀：记录测试脚本、数据构造方法、监控指标，方便后续回归测试或容量规划。

八、具体实现(10000条测试数据创建和10000次请求执行)

要快速完成10000条测试数据创建和10000次请求执行，需结合工具特性和效率优化技巧。以下分场景给出具体实现方案，涵盖数据生成、请求执行、效率优化三个核心环节，附工具示例和代码片段。

一、快速创建10000条测试数据

测试数据需满足“真实场景模拟+高效生成”，避免手动插入或单条写入的低效问题。根据数据库类型和数据复杂度，选择以下方法：

1. 关系型数据库（MySQL/PostgreSQL）

核心思路：批量插入 + 事务控制 + 禁用索引（可选），避免逐条提交和索引维护开销。

方法1：Python + Faker库（灵活定制，小数据量）

适合生成带业务属性的数据（如用户、订单），支持参数化字段（姓名、手机号、地址等）。

安装依赖：

pip install faker pymysql  # MySQL示例，PostgreSQL换为psycopg2

脚本示例（生成10000条用户数据并批量插入）：

python

from faker import Faker
import pymysql
import time

fake = Faker("zh_CN")  # 中文数据
DB_CONFIG = {"host": "test_db_host", "user": "test_user", "password": "test_pass", "db": "test_db"}

def generate_users(num=10000):
    users = []
    for _ in range(num):
        users.append((
            fake.name(),          # 姓名
            fake.phone_number(),  # 手机号
            fake.email(),         # 邮箱
            fake.date_of_birth()  # 出生日期
        ))
    return users

def batch_insert(users, batch_size=500):  # 分批插入，每批500条
    conn = pymysql.connect(**DB_CONFIG)
    cursor = conn.cursor()
    try:
        conn.autocommit(False)  # 关闭自动提交，开启事务
        sql = "INSERT INTO user (name, phone, email, birthday) VALUES (%s, %s, %s, %s)"
        start_time = time.time()
        for i in range(0, len(users), batch_size):
            cursor.executemany(sql, users[i:i+batch_size])
            conn.commit()  # 分批提交
            print(f"已插入 {min(i+batch_size, len(users))}/{len(users)} 条数据")
        print(f"插入完成，耗时：{time.time()-start_time:.2f}秒")
    except Exception as e:
        conn.rollback()
        print(f"插入失败：{e}")
    finally:
        cursor.close()
        conn.close()

if __name__ == "__main__":
    users = generate_users(10000)
    batch_insert(users)

优化点：
- batch_size设为500~2000（根据数据库配置调整，避免事务过大）；
- 插入前禁用索引（如 ALTER TABLE user DISABLE KEYS;），插入后重建索引（提升插入速度30%~50%）；
- 若数据无业务属性，可直接用SQL生成随机数据（见方法2）。

方法2：Sysbench（专业数据库压测工具，大数据量）

适合快速生成海量测试数据（如百万级），支持MySQL、PostgreSQL等，内置多种数据模型（用户、订单、商品）。

安装Sysbench：

# Ubuntu/Debian
sudo apt-get install sysbench
# CentOS/Fedora
sudo yum install sysbench

生成10000条用户数据：

# 初始化测试数据库（创建sbtest库）
sysbench oltp_read_write --db-driver=mysql --mysql-host=test_db_host --mysql-user=test_user --mysql-password=test_pass --mysql-db=test_db --tables=1 --table-size=10000 prepare

--tables=1：生成1张表；
--table-size=10000：每张表10000条数据；
数据模型默认是“订单表”，可自定义Lua脚本生成特定业务数据（如用户表）。

方法3：SQL脚本（纯数据库操作，极快）

适合生成无业务逻辑的随机数据（如测试用填充数据），通过 INSERT ... SELECT循环插入。

示例（生成10000条随机用户数据）：

-- 创建测试表
CREATE TABLE test_user (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(50),
    age INT,
    create_time TIMESTAMP
);

-- 批量插入（禁用索引+事务，10秒内完成10000条）
START TRANSACTION;
ALTER TABLE test_user DISABLE KEYS;

INSERT INTO test_user (name, age, create_time)
SELECT 
    CONCAT('user_', n), 
    FLOOR(RAND() * 50) + 18,  -- 年龄18~67岁
    NOW() - INTERVAL FLOOR(RAND() * 365) DAY  -- 随机注册时间（1年内）
FROM (
    SELECT a.N + b.N * 10 + 1 AS n
    FROM (SELECT 0 AS N UNION ALL SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5 UNION ALL SELECT 6 UNION ALL SELECT 7 UNION ALL SELECT 8 UNION ALL SELECT 9) a,
         (SELECT 0 AS N UNION ALL SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4 UNION ALL SELECT 5 UNION ALL SELECT 6 UNION ALL SELECT 7 UNION ALL SELECT 8 UNION ALL SELECT 9) b
    ORDER BY n
) numbers  -- 生成1~10000的数字序列
LIMIT 10000;

ALTER TABLE test_user ENABLE KEYS;
COMMIT;

2. 非关系型数据库（MongoDB/Redis）

MongoDB：用 `mongoimport`导入JSON/CSV

生成JSON数据（10000条用户数据，用Python脚本）：

python

import json
from faker import Faker

fake = Faker()
data = [{"name": fake.name(), "email": fake.email()} for _ in range(10000)]
with open("users.json", "w") as f:
    json.dump(data, f)

导入MongoDB：

mongoimport --host test_mongo_host --port 27017 --db test_db --collection users --file users.json --numInsertionWorkers 4  # 多线程导入

Redis：批量写入键值对

Python + Redis Pipeline（10000条缓存数据）：

python

import redis
import random

r = redis.Redis(host="test_redis_host", port=6379, db=0)
pipe = r.pipeline()

for i in range(10000):
    key = f"user:{i}"
    value = {"name": f"user_{i}", "age": random.randint(18, 60)}
    pipe.hset(key, mapping=value)  # 批量写入哈希表
    if i % 1000 == 0:  # 每1000条执行一次pipeline
        pipe.execute()

pipe.execute()  # 执行剩余命令

二、快速执行10000次请求

核心目标是并发控制+结果收集+错误重试，避免顺序执行（10000次串行请求太慢）或无限制并发（压垮测试环境）。

1. 图形化工具：Apache JMeter（新手友好，功能全面）

适合无代码基础的用户，可视化配置并发请求、参数化、断言。

步骤：
1. 新建测试计划 → 添加线程组：
  - 线程数：100（并发用户数）；
  - Ramp-up时间：10秒（10秒内启动100个线程，即每秒启动10个请求）；
  - 循环次数：100（每个线程执行100次，总请求=100线程×100次=10000次）。
2. 添加HTTP请求：
  - 协议/域名/IP：填写被测接口地址（如 http://api.test.com/order）；
  - 方法：POST/GET；
  - 参数：填写请求体（如JSON {"userId": "${userId}", "productId": "${productId}"}）。
3. 参数化：
  - 添加 CSV Data Set Config：
    - 文件路径：上传包含10000个用户ID/商品ID的CSV文件（如 data.csv，列名 userId,productId）；
    - 变量名：userId,productId（与请求参数中的 ${userId}对应）。
4. 断言：
  - 添加 Response Assertion：检查响应状态码=200，或响应体包含 "code": 0"（表示成功）。
5. 监听器：
  - 添加 聚合报告：查看吞吐量（QPS）、平均响应时间、错误率。
执行：点击“启动”，JMeter会按配置的并发数发送请求，结束后在监听器查看结果。

2. 轻量级脚本：Python + requests + 并发库（灵活定制，自动化）

适合需要集成到CI/CD或二次开发的场景，用 concurrent.futures控制并发。

安装依赖：

pip install requests pandas  # pandas用于读取CSV参数

脚本示例（并发执行10000次POST请求）：

python

import requests
import pandas as pd
from concurrent.futures import ThreadPoolExecutor, as_completed
import time

# 读取参数CSV（data.csv包含userId,productId两列）
df = pd.read_csv("data.csv")
total_requests = 10000
concurrency = 100  # 并发线程数

def send_request(row):
    url = "http://api.test.com/order"
    payload = {"userId": row["userId"], "productId": row["productId"]}
    headers = {"Content-Type": "application/json"}
    try:
        response = requests.post(url, json=payload, headers=headers, timeout=10)
        return {
            "success": response.status_code == 200 and response.json().get("code") == 0,
            "status_code": response.status_code,
            "error": None if response.ok else response.text
        }
    except Exception as e:
        return {"success": False, "status_code": None, "error": str(e)}

start_time = time.time()
success_count = 0
error_count = 0

# 使用线程池并发执行
with ThreadPoolExecutor(max_workers=concurrency) as executor:
    futures = [executor.submit(send_request, row) for _, row in df.head(total_requests).iterrows()]
    for future in as_completed(futures):
        result = future.result()
        if result["success"]:
            success_count += 1
        else:
            error_count += 1
        # 可选：实时打印进度
        processed = success_count + error_count
        if processed % 100 == 0:
            print(f"已处理 {processed}/{total_requests}，成功率：{success_count/processed:.2%}")

print(f"总请求：{total_requests}，成功：{success_count}，失败：{error_count}")
print(f"耗时：{time.time()-start_time:.2f}秒，QPS：{total_requests/(time.time()-start_time):.2f}")

优化点：
- concurrency控制并发线程数（根据被测系统承受能力调整，避免压垮对方）；
- 用 as_completed实时获取结果，避免阻塞；
- 支持从CSV/数据库读取参数，避免硬编码。

3. 高性能工具：k6（云原生友好，低资源消耗）

适合容器化环境（K8s），用JavaScript编写脚本，性能优于JMeter（相同机器资源下并发能力更强）。

安装k6：

brew install k6  # macOS
# 或下载二进制：https://k6.io/docs/getting-started/installation/

脚本示例（script.js，并发执行10000次请求）：

javascript

import http from 'k6/http';
import { check, sleep } from 'k6';

// 生成10000个用户的参数（或从CSV导入）
const userIds = Array.from({ length: 10000 }, (_, i) => i + 1); // 1~10000的用户ID

export let options = {
  vus: 100,       // 并发虚拟用户数（VUs）
  iterations: 100, // 每个VU执行100次迭代（总请求=100×100=10000）
  duration: '60s', // 最长执行时间（防止无限循环）
};

export default function () {
  const userId = userIds[Math.floor(Math.random() * userIds.length)]; // 随机取用户ID
  const payload = JSON.stringify({ userId, productId: Math.floor(Math.random() * 100) });

  const res = http.post('http://api.test.com/order', payload, {
    headers: { 'Content-Type': 'application/json' },
  });

  // 断言：状态码200且返回code=0
  check(res, {
    'status is 200': (r) => r.status === 200,
    'code is 0': (r) => r.json().code === 0,
  });

  sleep(0.1); // 模拟用户思考时间（避免无间隔请求）
}

执行：

k6 run script.js  # 运行脚本
k6 run --reporter=html script.js  # 生成HTML报告

4. 命令行工具：wrk（极简，高性能）

适合快速验证接口性能，单行命令发送高并发请求（需编译安装，适合Linux/macOS）。

安装wrk：

# 需先安装LuaJIT和make
git clone https://github.com/wg/wrk.git
cd wrk
make -j$(nproc)
sudo cp wrk /usr/local/bin

执行10000次请求：
```
wrk -t10 -c100 -d10s --latency --script=post.lua http://api.test.com/order
```
- -t10：10个线程；
- -c100：100个并发连接；
- -d10s：持续压测10秒（总请求≈100连接×(10000请求/10秒)=10000次，需调整时间或循环次数）；
- --script=post.lua：Lua脚本发送POST请求（见下方）。

post.lua脚本（发送JSON参数）：

lua

request = function()
  return wrk.format("POST", "/order", {
    ["Content-Type"] = "application/json"
  }, '{"userId": ' .. math.random(1, 10000) .. ', "productId": ' .. math.random(1, 100) .. '}')
end

三、效率优化总结

场景	推荐工具/方法	核心优化点
关系型数据库数据生成	Sysbench（大数据量）/ Python批量插入（小数据量）	禁用索引、事务批量提交、分批插入
非关系型数据库数据生成	mongoimport/redis-pipeline	并行导入、Pipeline减少网络往返
请求执行（新手）	JMeter	线程组+CSV参数化+聚合报告
请求执行（自动化/定制）	Python + requests + ThreadPoolExecutor	控制并发线程数、实时结果统计
请求执行（云原生）	k6	JavaScript脚本、低资源消耗、容器化友好
快速验证性能	wrk	单行命令、高并发、低开销