PHP 怎么压测脚本

wen PHP项目 2026-08-04 2

PHP压测脚本实战指南：从零构建高并发测试体系

目录导读

为什么PHP开发者需要自建压测脚本？
压测前的核心准备工作
PHP压测脚本的三种主流实现方案
基于curl多线程的压测脚本精讲
进阶：使用Swoole协程实现高性能压测
压测结果数据采集与可视化分析
常见问题FAQ与性能调优技巧

01 为什么PHP开发者需要自建压测脚本？

很多团队在项目上线前会使用JMeter、ab（ApacheBench）或wrk等通用工具进行压力测试，但PHP开发者在实际工作中常遇到以下痛点：

PHP 怎么压测脚本

业务逻辑复杂：需模拟登录态、签名参数、多步骤接口调用，通用工具难以灵活实现。
数据隔离需求：压测时需要向数据库写入特定测试数据，脚本需与PHP业务代码无缝衔接。
环境依赖：测试环境常需要调用PHP内部函数、读取框架配置（如Laravel的.env），外部工具需要额外适配。
快速迭代：每次代码变更后希望在IDE中一键触发压测，而不是切换到另一个重型工具。

自建PHP压测脚本带来的核心价值：完全复用现有业务代码的数据层与工具类，能精确构造业务请求，且极易集成到CI/CD流水线中。

问答Q1：自建脚本比JMeter更优吗？答：并非完全替代，对于多协议混合压测、分布式压测，JMeter生态更强，但PHP脚本在定制化请求生成、结果与业务日志联动方面优势显著，尤其适合快速验证API修改后的性能回归。

02 压测前的核心准备工作

编写第一行压测代码前,必须明确以下参数与边界：

目标接口与请求方法（GET/POST/PUT/DELETE）、请求头、请求体格式。
并发模型：总请求数（如10000次）、并发用户数（如50/100/200）、持续时间（若按时间压测）。
前置数据准备：是否需要构造唯一手机号、用户ID等，防止唯一索引冲突。
监控指标：平均响应时间（ART）、百分位响应时间（P95/P99）、错误率、QPS（每秒查询数）、系统CPU/内存使用率。
压测对象隔离：服务端日志需能区分压测流量与真实流量，通常添加特殊请求头如X-Test-Flag: 1。

代码骨架示例（保存为bootstrap.php用于加载框架环境）：

<?php
require __DIR__ . '/vendor/autoload.php';
// 若为Laravel项目，则加载框架核心
$app = require_once __DIR__ . '/bootstrap/app.php';
$kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
?>

问答Q2：压测前必须清理缓存吗？答：如果需要评估缓存命中后的性能，则不清理；若要测真实后端逻辑（含Redis、MySQL查询），务必先清空Redis缓存和Opcache，建议同时压测两个场景：带缓存与不带缓存，以定位性能瓶颈。

03 PHP压测脚本的三种主流实现方案

方案类型	技术栈	适用场景	最大并发瓶颈
方案A：单线程循环	`curl`扩展	快速功能验证，关注响应内容	极低，约10-50 QPS
方案B：多进程/多线程	`pcntl_fork` 或 `pthreads`	中等并发，需模拟真实用户操作	受PHP进程数/线程数限制，约100-500并发
方案C：异步协程	Swoole / ReactPHP	高并发、长连接接口压测	轻松上千并发，内存占用极低

方案B实现细节（推荐优先使用）：利用pcntl_fork()创建N个子进程，每个子进程独立循环发送请求，注意点：

每个子进程需重新初始化数据库连接（避免共享连接导致崩溃）。
使用posix_kill和pcntl_wait管理子进程生命周期。
结果写入独立临时文件,最后汇总。

方案C（Swoole）核心优势：协程调度，单进程能创建上万协程，消除进程创建开销，但对于熟悉的团队，学习曲线稍陡。

04 基于curl多线程的压测脚本精讲

以下提供一个可直接运行的压测脚本模板（支持并发控制、数据统计、错误捕获）。

文件：stress_test.php

<?php
/**
 * 一个健壮的多进程压测脚本（适用于类Unix系统）
 */
class StressTester {
    private $url;
    private $method;
    private $postData;
    private $headers;
    private $totalRequests;
    private $concurrency;
    public function __construct($url, $method = 'GET', $postData = [], $headers = []) {
        $this->url = $url;
        $this->method = $method;
        $this->postData = $postData;
        $this->headers = $headers;
    }
    public function setLoad($totalRequests, $concurrency) {
        $this->totalRequests = $totalRequests;
        $this->concurrency = $concurrency;
    }
    private function doRequest() : array {
        $ch = curl_init($this->url);
        if ($this->method === 'POST') {
            curl_setopt($ch, CURLOPT_POST, true);
            curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($this->postData));
        }
        if (!empty($this->headers)) {
            curl_setopt($ch, CURLOPT_HTTPHEADER, $this->headers);
        }
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_TIMEOUT, 30); // 超时30秒
        $start = microtime(true);
        $response = curl_exec($ch);
        $error = curl_error($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $end = microtime(true);
        curl_close($ch);
        return [
            'code' => $httpCode,
            'time' => round(($end - $start) * 1000, 2), // 毫秒
            'error' => $error ?: null
        ];
    }
    public function run() {
        $resultFile = tempnam(sys_get_temp_dir(), 'st_');
        $totalProcess = min($this->concurrency, $this->totalRequests);
        if ($totalProcess <= 0) {
            die("并发数必须大于0");
        }
        // 每个进程分配请求数
        $perProcess = intval($this->totalRequests / $totalProcess);
        $remainder = $this->totalRequests % $totalProcess;
        for ($i = 0; $i < $totalProcess; $i++) {
            $pid = pcntl_fork();
            if ($pid == -1) {
                die("无法创建子进程");
            } elseif ($pid) {
                // 父进程记录子进程ID
            } else {
                // 子进程执行逻辑
                $currentRemainder = ($i < $remainder) ? 1 : 0;
                $count = $perProcess + $currentRemainder;
                $results = [];
                for ($j = 0; $j < $count; $j++) {
                    $results[] = $this->doRequest();
                }
                file_put_contents($resultFile, json_encode($results) . PHP_EOL, FILE_APPEND);
                exit(0);
            }
        }
        // 父进程等待所有子进程完成
        while (pcntl_waitpid(0, $status) != -1) {
            // 等待所有子进程退出
        }
        // 汇总分析
        $this->analyze($resultFile);
        unlink($resultFile);
    }
    private function analyze($filePath) {
        $allErrors = [];
        $times = [];
        $codesCount = [];
        $content = file_get_contents($filePath);
        $lines = explode("\n", trim($content));
        foreach ($lines as $line) {
            $data = json_decode($line, true);
            if (!$data) continue;
            foreach ($data as $reqResult) {
                $times[] = $reqResult['time'];
                $codesCount[$reqResult['code']] = ($codesCount[$reqResult['code']] ?? 0) + 1;
                if ($reqResult['error']) {
                    $allErrors[] = $reqResult['error'];
                }
            }
        }
        // 计算指标
        $total = count($times);
        $avg = round(array_sum($times) / $total, 2);
        $max = max($times);
        $min = min($times);
        sort($times);
        $p95 = $times[intval($total * 0.95)] ?? 0;
        $p99 = $times[intval($total * 0.99)] ?? 0;
        $qps = round($total / (array_sum($times) / 1000), 2);
        echo "=== 压测结果汇总 ===" . PHP_EOL;
        echo "总请求数: {$total}" . PHP_EOL;
        echo "平均响应时间(ms): {$avg}" . PHP_EOL;
        echo "最小/最大(ms): {$min}/{$max}" . PHP_EOL;
        echo "P95 (ms): {$p95}" . PHP_EOL;
        echo "P99 (ms): {$p99}" . PHP_EOL;
        echo "QPS (请求/秒): {$qps}" . PHP_EOL;
        echo "成功率: " . round((($total - count($allErrors)) / $total) * 100, 2) . "%" . PHP_EOL;
        echo "状态码分布: " . json_encode($codesCount) . PHP_EOL;
        if (count($allErrors) > 0) {
            echo "错误示例: " . implode(", ", array_slice(array_unique($allErrors), 0, 5)) . PHP_EOL;
        }
    }
}
// 使用示例
$tester = new StressTester(
    'http://api.example.com/v1/users',
    'GET',
    [],
    ['X-Test-Flag: 1', 'Accept: application/json']
);
$tester->setLoad(1000, 50); // 总请求1000，并发50
$tester->run();

关键代码解释：

pcntl_fork()确保每个进程独立工作，避免curl句柄串用。
临时文件让各进程异步写结果,避免内存堆积。
量化指标计算,直接输出决策依据。

问答Q3：压测中如何处理超时请求（如某些接口特别慢）？答：在doRequest()中设置CURLOPT_TIMEOUT为业务容忍最大值（如30秒），分析结果时，超时会被记录为错误，并包含在错误率内，建议同时记录超时时间，便于判断是服务端僵死还是网络问题。

05 进阶：使用Swoole协程实现高性能压测

当需要模拟500以上并发时,多方案的进程开销会很大，Swoole能够高效处理此场景。

核心思路：利用Swoole\Coroutine创建N个协程，每个协程循环发起请求，通过Channel汇总结果。

示例代码片段：

<?php
use Swoole\Coroutine;
use Swoole\Coroutine\Channel;
use function Swoole\Coroutine\run;
run(function () {
    $concurrency = 2000; // 高并发
    $totalRequests = 20000;
    $url = 'http://api.example.com/benchmark';
    $chan = new Channel($concurrency * 2);
    $startTime = microtime(true);
    for ($i = 0; $i < $concurrency; $i++) {
        Coroutine::create(function () use ($chan, $totalRequests, $concurrency, $url) {
            $perTask = intval($totalRequests / $concurrency);
            for ($j = 0; $j < $perTask; $j++) {
                $client = new Swoole\Coroutine\Http\Client('api.example.com', 80);
                $client->set(['timeout' => 5]);
                $begin = microtime(true);
                $client->get('/benchmark');
                $cost = (microtime(true) - $begin) * 1000;
                $chan->push(['cost' => $cost, 'status' => $client->statusCode]);
                $client->close();
            }
        });
    }
    // 统计协程
    $costs = [];
    $successCount = 0;
    $totalCount = 0;
    while ($data = $chan->pop()) {
        $costs[] = $data['cost'];
        if ($data['status'] >= 200 && $data['status'] < 300) {
            $successCount++;
        }
        $totalCount++;
    }
    $endTime = microtime(true);
    $duration = $endTime - $startTime;
    $avgCost = array_sum($costs) / count($costs);
    $qps = $totalCount / $duration;
    echo "QPS: " . round($qps, 2) . PHP_EOL;
    echo "平均耗时: " . round($avgCost, 2) . "ms" . PHP_EOL;
    echo "成功率: " . round(($successCount / $totalCount) * 100, 2) . "%" . PHP_EOL;
});

注意事项：

Swoole的HTTP客户端不使用curl,网络处理更底层，速度更快。
需确保服务器同时打开--enable-coroutine。
压测过程中监听内存,Swoole协程内存占用约2KB/协程，2000并发仅需4MB左右，表现优秀。

06 压测结果数据采集与可视化分析

光有终端输出不足以指导调优,建议将压测结果以结构化数据（如JSON或CSV）持久化，然后加载到图表中。

丰富输出示例：将分析结果输出为JSON，供Grafana或自建前端展示。

// 在analyze方法末尾添加输出JSON文件
$summary = [
    'time' => date('Y-m-d H:i:s'),
    'total' => $total,
    'avg_ms' => $avg,
    'max_ms' => $max,
    'min_ms' => $min,
    'p95_ms' => $p95,
    'p99_ms' => $p99,
    'qps' => $qps,
    'success_rate' => round(($total - count($allErrors)) / $total * 100, 2),
    'status_codes' => $codesCount
];
file_put_contents('stress_result_' . date('His') . '.json', json_encode($summary));

图表可视化建议：

使用Console_Table类在终端生成ASCII图表。
或简单绘制在HTML中使用Chart.js。
时间序列数据（每秒QPS、响应时间演变）建议记录每个请求的耗时，导出后用Excel绘制折线图。

07 常见问题FAQ与性能调优技巧

FAQ专集

Q4：压测时遇到"Too many open files"错误？

答：这是操作系统文件描述符限制，执行ulimit -n 65535提升限制，并在脚本开头调用ini_set('xdebug.max_nesting_level', 5000)（若开启Xdebug），检查脚本中是否有未关闭的curl句柄。

Q5：压测目标服务返回大量500错误，但浏览器访问正常？

答：可能因QPS过高触发服务器限流或防火墙，检查Nginx的limit_req配置，以及PHP-FPM的pm.max_children，查看PHP错误日志中是否出现"Too many connections"。

Q6：脚本运行中途内存耗尽怎么办？

答：若使用多进程方案，子进程内存是隔离的，父进程仅汇总结果，但若将所有结果存入一个数组而不用临时文件，会导致内存耗尽，请严格按照本文的临时文件方法，对于Swoole协程，注意释放$client对象，并减小变量作用域。

性能调优技巧

连接复用：若压测接口支持Keep-Alive，在curl中设置CURLOPT_TCP_KEEPALIVE => 1，能显著降低建连开销。
数据采样：不要在真实生产库执行压测，避免脏数据，使用独立的测试MySQL实例并预先建立索引。
预热环境：首次请求会生成缓存、加载类映射等，建议先进行100次小流量热身请求，再正式压测。
分阶段加压：从低并发（如50）逐步到高并发（如1000），观察服务崩溃的临界点，避免一次性压垮。
监控服务端：在目标服务器上执行top -H -p php-fpm进程ID或使用perf查看CPU占用，判断瓶颈是CPU密集型还是IO等待。

最终建议

压测脚本的价值在于发现问题而不只是数字,建议将压测脚本集成到CI的每晚定时任务中，自动对比性能回归，当发现阈值（如P95 > 500ms）时，自动触发告警邮件，PHP社区拥有丰富的扩展（如xhprof），结合压测脚本，可以精确分析每个函数的耗时，形成质量闭环。

您已具备从零构建PHP压测脚本的完整知识框架,选择适合您场景的方案，开始实战吧！请确保压测仅在您有权限控制的测试环境或预发布环境进行，勿对公网未授权站点发起压力测试。