Python / 系统课时

用并发压测找出瓶颈

用并发压测找出瓶颈

并发压测不是把连接数调到最大,而是用可重复的负载逐步逼近系统边界,再把吞吐、延迟、错误率和资源使用放到同一时间线上判断。本节实现一个 asyncio 压测客户端,并用分阶段实验区分服务处理慢、并发上限和客户端自身过载。

学习目标

  • 用固定并发度生成持续 TCP 请求,并记录成功数、错误数和请求延迟
  • 根据吞吐、P50/P95、错误率与 CPU、内存、网络占用判断瓶颈位置
  • 通过递增并发和控制变量设计可复现的压测场景

先定义压测观察点

一次有效压测至少要同时回答四个问题:单位时间完成了多少请求、典型请求多快、尾部请求有多慢、失败是否开始增加。只看 RPS 会掩盖排队问题,只看平均延迟又会把少量慢请求冲淡,因此示例同时输出 RPS、P50、P95、错误数和错误率。

并发压测的数据路径与观测点

为了让实验可独立运行,下面脚本同时提供测试服务和压测模式。服务收到一行数据就返回 OK,并可人为增加处理延迟;压测模式让每个 worker 维持一个长连接,持续发送请求直到测试时间结束。

实现可重复的并发压测

将以下代码保存为 load_lab.py。先在一个终端运行 python load_lab.py server --port 9000 --delay-ms 0,再在另一个终端运行 python load_lab.py load --port 9000 --concurrency 100 --seconds 5。示例协议很小,但压测方法同样适用于你自己的 TCP 服务。

python
import argparse
import asyncio
import time

async def handle_client(
    reader: asyncio.StreamReader,
    writer: asyncio.StreamWriter,
    delay_ms: float,
) -> None:
    try:
        while True:
            line = await reader.readline()
            if not line:
                return

            if delay_ms > 0:
                await asyncio.sleep(delay_ms / 1000)

            writer.write(b"OK\n")
            await writer.drain()
    finally:
        writer.close()
        try:
            await writer.wait_closed()
        except ConnectionError:
            pass

async def run_server(args: argparse.Namespace) -> None:
    tasks = set()

    def on_client(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
        task = asyncio.create_task(handle_client(reader, writer, args.delay_ms))
        tasks.add(task)
        task.add_done_callback(tasks.discard)

    server = await asyncio.start_server(on_client, args.host, args.port)
    print(
        f"server listening on {args.host}:{args.port} "
        f"delay_ms={args.delay_ms}"
    )
    async with server:
        await server.serve_forever()

def percentile(values: list[float], ratio: float) -> float:
    ordered = sorted(values)
    if not ordered:
        return 0.0
    index = int((len(ordered) - 1) * ratio)
    return ordered[index] * 1000

async def run_load(args: argparse.Namespace) -> None:
    loop = asyncio.get_running_loop()
    deadline = loop.time() + args.seconds
    latencies = []
    ok = 0
    errors = 0

    async def worker() -> None:
        nonlocal ok, errors

        try:
            reader, writer = await asyncio.open_connection(args.host, args.port)
        except OSError:
            errors += 1
            return

        try:
            while loop.time() < deadline:
                started = time.perf_counter()
                try:
                    writer.write(b"ping\n")
                    await writer.drain()
                    response = await asyncio.wait_for(
                        reader.readline(),
                        timeout=args.timeout,
                    )
                except (TimeoutError, ConnectionError):
                    errors += 1
                    return

                if response != b"OK\n":
                    errors += 1
                    return

                latencies.append(time.perf_counter() - started)
                ok += 1
        finally:
            writer.close()
            await writer.wait_closed()

    started = time.perf_counter()
    await asyncio.gather(
        *(worker() for _ in range(args.concurrency))
    )
    elapsed = time.perf_counter() - started

    total = ok + errors
    error_rate = errors / total * 100 if total else 0.0
    print(
        f"completed={ok} "
        f"rps={ok / elapsed:.1f} "
        f"p50_ms={percentile(latencies, 0.50):.2f} "
        f"p95_ms={percentile(latencies, 0.95):.2f} "
        f"errors={errors} "
        f"error_rate={error_rate:.2f}%"
    )

def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser()
    sub = parser.add_subparsers(dest="mode", required=True)

    server = sub.add_parser("server")
    server.add_argument("--host", default="127.0.0.1")
    server.add_argument("--port", type=int, default=9000)
    server.add_argument("--delay-ms", type=float, default=0.0)

    load = sub.add_parser("load")
    load.add_argument("--host", default="127.0.0.1")
    load.add_argument("--port", type=int, default=9000)
    load.add_argument("--concurrency", type=int, default=100)
    load.add_argument("--seconds", type=float, default=5.0)
    load.add_argument("--timeout", type=float, default=1.0)

    return parser.parse_args()

async def main() -> None:
    args = parse_args()
    if args.mode == "server":
        await run_server(args)
    else:
        await run_load(args)

if __name__ == "__main__":
    asyncio.run(main())

预期输出

text
server listening on 127.0.0.1:9000 delay_ms=0.0
completed=<COUNT> rps=<RPS> p50_ms=<MS> p95_ms=<MS> errors=<COUNT> error_rate=<PERCENT>%

<COUNT>、<RPS>、<MS> 和 <PERCENT> 会随机器性能、并发度和调度情况变化。关键不是追求某个固定数字,而是保证同一环境、同一代码版本下的测试参数可复现。

用阶梯负载找拐点

不要一开始就用极高并发。更有效的方法是固定每轮测试时长,依次把并发度从 10、50、100 提升到 200 或更高,并记录每轮的 RPS、P95 和错误率。若 RPS 继续增长且 P95 基本稳定,说明系统还有余量;若 RPS 增长趋缓而 P95 快速上升,通常已经出现排队。

然后只改变一个变量。把服务的 --delay-ms 从 0 调到 20,可以人为制造服务端处理时间,观察吞吐上限如何下降;保持服务不变却不断提高压测客户端并发,如果客户端 CPU 已经接近饱和,那么测到的可能是压测机上限,而不是服务端上限。

现象 更可能的限制因素 下一步检查
RPS 不再增长,P95 持续上升 服务端排队或下游变慢 CPU、事件循环延迟、数据库或外部调用
错误率突然升高 连接数、文件描述符、超时或限流 服务日志、连接上限、超时配置
服务端资源很低,客户端 CPU 很高 压测端先到上限 降低单机并发或拆分多台压测机
CPU 不高但网络接近带宽上限 网络吞吐成为瓶颈 网卡吞吐、包量、跨机链路

把资源使用和请求指标对齐

吞吐与延迟只能告诉你“变慢了”,资源指标才帮助判断“为什么”。压测期间应同时记录服务进程 CPU、内存、打开连接数和网络吞吐;Linux 可用 top、pidstat、ss 等工具,容器环境则可查看运行时或监控系统中的对应指标。

判断时要对齐时间窗口。例如某一轮并发从 100 提高到 200 后,P95 翻倍而 CPU 从 60% 升到接近 100%,CPU 饱和是强线索;如果 CPU 仍低但连接数卡在固定值,优先检查连接限制;如果所有本机指标都正常而请求延迟抬升,应继续看数据库、缓存或远程 API。

如何确认瓶颈已经被找到

真正的瓶颈应能通过控制变量被重复触发和缓解。比如把并发度提高时 P95 稳定恶化,而提升服务端 CPU 配额后同样负载下 P95 明显下降,这比“CPU 看起来很高”更有说服力。反过来,如果调整某项资源后吞吐和延迟几乎不变,就不应把它当作根因。

压测的目标不是制造一个最大的 RPS 数字,而是找到吞吐停止线性增长、尾延迟开始失控或错误率抬升的拐点,再用资源证据验证限制因素。这样得到的结论才可以指导容量规划和下一轮优化。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

用并发压测找出瓶颈

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通