跳转到内容
文档

生产环境与性能

框架在运行时的开销,以及如何构建、调优并发布缓存,让生产环境只为带有 behavior 的调用付出开销。

本页译自英文,以英文页面为准。 阅读原文

框架会把你的类连同它们的 behavior(行为)编译一次,并把结果存成普通的 PHP 文件。此后这些文件和其他代码一样被加载:OPcache 缓存它们,Composer 加载它们,请求期间不会运行任何解析器、反射或 eval()。缓存就绪时,一个生产请求只读取一个元数据文件,把生成的类交给 Composer,并且只为真正被拦截的调用付出开销。没有 behavior 的方法和属性没有任何开销。

本页给出实测数据,解释开销从何而来,并说明如何发布缓存:部署时预热、OPcache、Composer、Docker 和 Kubernetes。内核选项见 配置与命令行。直观的总结见 Performance 特性页面。

本页所有数据都来自 goaop/framework 上游的 docs/performance.md。它们是在同一台机器上测得的,所以请把它们看作不同模式之间的比例。能推广到其他机器上的,正是这些比例。

  • 一个小型商店应用:包含路径(include paths)下约 250 个文件(其中 94 个类被编译),包含路径之外的 120 个库类,以及 6 个 behavior class(行为类),用到了 #[Before]、#[Around]、#[AfterThrowing] 和属性上的 behavior。
  • 一个请求下 50 个订单。这会产生约 2,600 次被拦截的方法调用和约 950 次被拦截的属性访问。
  • PHP 8.5.12 NTS,4 个 CPU,OPcache 使用共享内存,opcache.jit=disable,opcache.file_update_protection=0。

完整的测量方法见下文 复现基准测试。

三种缓存状态:

  • hot:编译缓存已存在,OPcache 已填充。这是生产 worker 的稳定状态。
  • warm:编译缓存已存在,OPcache 为空。对应刚启动的 PHP-FPM 或新的 pod。
  • cold:还没有任何缓存。第一个请求会编译它加载的每一个类。
模式 hot warm 峰值内存(hot)
debug => false + PREBUILT_CACHE 5.4 ms 59 ms 1.3 MB
debug => false 5.5 ms 62 ms 1.3 MB
debug => true 13.0 ms 63 ms 2.2 MB
不使用框架的同一个应用(behavior 不运行) 2.1 ms 36 ms 0.7 MB
  • 约 3,500 次带有真实 behavior 逻辑(日志、缓存查找、计时器)的拦截,让请求增加约 3.3 ms,其中内核启动约占 0.15 ms。
  • 一次被拦截的调用大约耗时三分之一微秒,每多叠加一个 behavior 约增加 70 ns。
  • 用 cache:warmup:aop 构建整个缓存不到半秒。一个 2,000 个文件的应用用 4 个 worker 需要 1.1 s。
  • 容器一启动就是 hot 状态。有了预先填充的 OPcache 文件缓存,新 PHP-FPM 的第一个请求耗时 19 ms,而不是 71 ms;再加上预加载则为 10 ms,与不使用框架的普通应用(9 ms)持平。

这些数据使用的是空 behavior,因此只衡量框架自身的工作:call context(调用上下文)、拦截器链,以及对原始方法的调用。

调用 单次调用开销
已编译类中没有 behavior 的方法或属性 0
带一个 #[Before] 或 #[Around] 的方法 ~0.33 µs
带三个 #[Around] 的方法 ~0.48 µs
带一个 #[Around] 的静态方法 ~0.34 µs
带一个 #[Around] 的属性读取 ~0.22 µs
带一个 #[Around] 的属性写入 ~0.26 µs

一百万次被拦截的调用大约耗时三分之一秒。一个有几百次拦截的典型请求,开销只有零点几毫秒。

每个 CLI 进程启动时 OPcache 都是空的。预先填充的 opcache.file_cache 能让短时运行的命令启动得几乎和 hot 状态的 Web 请求一样快。

每个进程的脚本耗时 关闭 OPcache 开启 OPcache(仅内存) opcache.file_cache,已预填充
PREBUILT_CACHE 33 ms 69 ms 21 ms
debug => false 30 ms 69 ms 22 ms
不使用框架 19 ms 34 ms 10 ms

代理只覆盖带有 behavior 的成员。其他所有方法和属性都是你的原始代码,全速运行:开销为 0。没有被任何 matching rule(匹配规则)选中的类根本不会被编译。

每个被拦截的方法都声明一个静态 call context:

static $__joinPoint = InterceptorInjector::forMethod(...)

Call context 及其拦截器列表在第一次调用时构建。之后的每次调用都只是一次 $__joinPoint->__invoke($this, [$args])。这个列表保存的是一等可调用对象(first-class callable),直接指向你的 behavior class 中的方法,因此既不需要查找 behavior,也没有反射和 __call()。

方法上的第一个 behavior 约耗时 0.33 µs。每多一个 behavior 增加约 70 ns,因此三个 #[Around] behavior 约耗时 0.48 µs。带一个 #[Around] 的静态方法约耗时 0.34 µs。

Behavior 所用的反射(getMethod()、getField())只在 behavior 请求时才会创建。

属性拦截会被编译为代理上原生的 PHP 8.4 get 和 set 钩子。没有 __get() 或 __set() 魔术方法,每次访问也不做反射。带一个 #[Around] 的属性读取约耗时 0.22 µs,写入约 0.26 µs。

在基准测试中,内核启动约耗时 0.15 ms。框架的服务、转换器(transformer)和你的 behavior class 都注册为工厂,每个只是一次数组写入。启动时不会自动加载、反射或创建任何东西,因此 warm 请求从不加载解析器、matching rule 语法、behavior 匹配器或转换器。

  • 缓存索引(CachePathManager)是唯一在 init() 中构建的服务,因为自动加载器会立即读取类映射(class map)。
  • Behavior class 在它的某个 behavior 第一次被调用时才创建,形式是 PHP 8.4 的原生惰性对象。Compile step(编译步骤)和缓存预热从不创建 behavior class,只读取它。
  • 生产环境不挂接任何注册监听器。调试模式通过一个监听器跟踪 behavior class 文件的变化,这个监听器借助 Composer 解析文件位置,而不加载这些类。
  • Matching rule 语法的解析表是生成好的 PHP 代码,规则只在首次使用时才解析。

warm 请求(编译缓存已存在,OPcache 为空)在使用 PREBUILT_CACHE 时耗时 59 ms,普通应用为 36 ms。可以用预先填充的 opcache.file_cache 和预加载来缩短它,见 Docker 与 Kubernetes。

cold 请求会编译它加载的每一个类。在部署时构建缓存并启用 PREBUILT_CACHE 后,生产请求永远不会触发编译。

编译只在部署时进行一次。

  • 基准测试应用的缓存不到半秒即可构建完成。
  • 一个 2,047 个文件的应用在 4 个 CPU 上,用一个 worker 耗时 2.2 s,用 4 个 worker 耗时 1.1 s。
  • 编译期间,每个保留在内存中的已解析文件约占 0.2 MB。内核选项 parsedFilesLimit(默认 100)限制最多保留多少个。

让编译保持快速的原因:

  • 缓存命中的路径不做任何解析。新鲜的记录在任何转换器出现之前就作为缓存内容返回。流过滤器(stream filter)和转换器链只在第一次未命中时才构建。
  • 所有改写规则共用一次语法树遍历。如果某条规则的源码标记没有出现在文件中,这条规则就会被跳过;没有任何适用规则的文件根本不会被遍历。大多数文件都属于这种情况。
  • 这些机制由你的 behavior class 来开启。只有在注册了 initialization(...) 规则时,new 表达式才会被改写。函数代理只在有函数规则时才存在。
  • Behavior class 检查需要反射每一个祖先类,它只对带有 behavior 的类运行。
  • Behavior class 中的 behavior 被缓存为一个由静态构造表达式组成的普通 PHP 文件,加载速度大约是 unserialize() 的两倍。
  • 代理以语法树的形式构建,只打印一次(编译时间 −43 %)。生成的 trait 通过 token 级编辑产生,保留你的行号,供 Xdebug 使用。
步骤 debug => false(+ PREBUILT_CACHE) debug => true
内核 init() 选项、容器、服务工厂(不创建任何对象) 同左,另外跟踪内核文件和 behavior class 文件的变化
_include.cache(类映射、跳过集合) 一次 include,由 OPcache 提供,不对缓存目录做 stat() 同左
已编译的类 Composer 类映射 → 缓存文件,来自 OPcache 新鲜度检查,然后经过流过滤器,让 Xdebug 断点和魔术常量指向你的原始文件
包含路径下未转换的类 跳过集合 → 原始文件,来自 OPcache 新鲜度检查 → 原始文件,来自 OPcache
解析器、转换器、流过滤器 从不加载 注册流过滤器,不构建转换器
修改过的源文件 按原样提供部署时构建的缓存 在下一个请求中重新编译

性能分析器统计的单个 hot 请求的文件系统调用:

调用 PREBUILT_CACHE debug => false debug => true 不使用框架
filemtime / filesize 0 0 323 / 239 0
file_get_contents 0 0 94 0
file_exists(Composer PSR-4) 307 307 412 357

生产请求不检查任何源文件。它需要的 Composer 查找甚至比普通应用还少,因为生成的类直接来自类映射。优化过的 Composer 类映射会消除剩下的查找,见 Composer 自动加载器。

运行时索引还有两个细节:

  • _include.cache 只保存请求所需的内容:类映射、跳过集合和包含映射(include map)。完整的构建记录放在 _transformation.cache 中,生产环境从不读取它。
  • 两个元数据文件都是用 var_export() 导出的数组,路径相对于 __DIR__。OPcache 把它们作为不可变数据保存在共享内存中,所以 include 它们不会复制任何内容,应用目录移动后缓存也依然有效。

调试模式是为开发准备的。在基准测试中,它的 hot 请求耗时约 13 ms,生产模式约 5.5 ms。调试模式仍然按原始路径 include 新鲜的未转换文件,因此 OPcache 会缓存它们(每个文件约 38 µs → 约 10 µs,调试请求快 27–40 %)。

  1. 设置 'debug' => false 和 'features' => Features::PREBUILT_CACHE。

  2. 在部署或构建镜像时用 cache:warmup:aop 构建缓存。

  3. 让 includePaths 保持精简:只放你的 src/,不放 vendor/。

  4. 用 addLazyService() 注册 behavior class。

  5. 用 composer install --no-dev --classmap-authoritative 安装依赖。

  6. 运行 OPcache 时设置 opcache.validate_timestamps=0,并为生成的文件留出足够的内存和文件槽位。

  7. 在容器中,把缓存构建进镜像,并加上预先填充的 opcache.file_cache 或预加载。

生产环境的内核:

public/index.php
use Go\Aop\Features;
ApplicationAspectKernel::getInstance()->init([
'debug' => false,
'appDir' => __DIR__ . '/..',
'cacheDir' => __DIR__ . '/../var/cache/aop',
'includePaths' => [__DIR__ . '/../src'],
'features' => Features::PREBUILT_CACHE,
]);
终端窗口
rm -rf var/cache/aop
vendor/bin/aspect cache:warmup:aop public/index.php --workers=$(nproc)

从空目录开始,让缓存恰好只包含当前发布的版本。参数是初始化内核的文件:前端控制器或引导文件。命令会执行这个文件,因此内核以与生产环境相同的选项启动。

该命令:

  • 编译 includePaths 下(去掉 excludePaths)的每个文件,写出生成的文件、代理、behavior class 缓存和两个元数据文件;
  • 把每个无法编译的文件报告到 stderr,并以非零退出码退出,这样部署脚本或 docker build 会就此停下,而不会发布一个不完整的缓存。

只要代码、behavior class、内核选项或 composer.lock 发生变化,就要重建缓存。实际上,这意味着每次部署都要重建。调试模式不需要重建:它会自行重新编译修改过的类、behavior class 和内核文件。

完整的命令签名:

cache:warmup:aop [<loader>] [--fail-fast] [--workers=N] [--cached-files=N] [--cache-dir=DIR] [--preload[=FILE]]

在已经初始化了内核的应用中(比如框架集成提供的控制台),省略 loader 参数,命令会使用当前进程的内核。见 集成。

--workers=N 在 N 个 worker 进程中编译,最大的文件优先。默认值为 1,即在命令进程本身中编译。设为 CPU 的数量即可。协调进程只写一次元数据,每个进程在内存中保留的语法树数量都有上限。

--cached-files=N 设置每个进程的这个上限,默认取内核选项 parsedFilesLimit 的值(100)。缓存的文件越多,重新解析就越少;越少则内存占用越低。加上 -v 会逐个列出文件,而不显示进度条。

--cache-dir=DIR 在另一个目录中从头构建缓存,内核则继续从它自己的目录提供服务。用它可以在运行中的版本旁边准备好下一个版本的缓存,再以原子方式切换过去,例如替换符号链接。

用这种方式构建的缓存是完整的,并且与位置无关,即使构建它的是一个自身缓存已经预热的生产内核。编译器总是读取它所反射的类的原始源码,从不读取生产环境中由 Composer 提供的生成文件。

在已有的目录上运行时,命令会重新编译源码有变化(大小或修改时间)的每个文件,其余文件保持不变。启用 PREBUILT_CACHE 时同样如此:只有请求会原样信任缓存,预热命令不会。

Features::PREBUILT_CACHE 让请求完全信任部署时构建的缓存。它会跳过:

  • 缓存目录及其可写性探测;
  • 源文件的 filemtime 比较;
  • 被跟踪资源的检查;
  • Behavior class 缓存的新鲜度检查。

请求永远不会编译,也永远不会写入缓存目录,因此可以在只读文件系统上运行。也正因为如此,缓存必须是完整的。如果包含路径下的某个类或被 include 的文件在缓存中没有记录,或者某条记录对应的缓存文件已经不存在,请求会在编译任何东西之前以 WeavingException 失败。构建之后新增的文件也算在内,哪怕它根本不需要编译。

编译器从不处理的文件按原样加载:包含路径之外的文件、被排除的文件,以及非 .php 文件,例如被 include 的模板。

每个缓存文件都先写入一个唯一的临时文件,再重命名到目标位置,然后在 OPcache 中失效。并发请求永远不会看到写了一半的文件,不需要锁,并发写入元数据的进程会合并各自的记录。

没有被编译的类照常由 Composer 查找。使用优化过的类映射时,每次查找都是一次数组访问,而不是一次 file_exists(),生成类的类映射则通过 addClassMap() 合并进去。这样,生成的类和未转换的类就以同样的方式提供。

基准测试中的 hot 请求:

自动加载器 PREBUILT_CACHE debug => false 不使用框架
PSR-4(composer install) 5.5 ms 6.7 ms 2.3 ms
--optimize-autoloader(-o) 5.2 ms 5.0 ms 1.6 ms
--classmap-authoritative(-a) 4.8 ms 4.6 ms 1.9 ms

使用 --classmap-authoritative 时,Composer 从不在类映射之外查找类。在任何代码生成之后、预热之前,运行 dump-autoload。

每个被编译的类都会变成两个缓存文件:作为 trait 的原始类体,以及代理。每个 behavior class 还有一个自己的缓存文件。给 OPcache 留出容纳它们的空间。

设置 生产环境取值 原因
opcache.enable 1 生成的代码是普通的 PHP,和应用的其余部分一样被缓存。
opcache.memory_consumption 128–256(MB) 在负载下检查 opcache_get_status()['memory_usage']。
opcache.interned_strings_buffer 16–32(MB) 代理和生成的 trait 共用类名和方法名。
opcache.max_accelerated_files ≥ 应用与 vendor/ 中 PHP 文件数的 2 倍 每个被编译的类都会增加一个文件。
opcache.validate_timestamps 0 发布版本和容器都是不可变的:每次 include 无需 stat。部署后重新加载 PHP-FPM。
opcache.file_update_protection 0 框架以原子方式写入每个缓存文件,因此 OPcache 可以立即缓存新生成的文件,而不必等待 2 秒(默认值)。
opcache.file_cache 一个目录 磁盘上的二级缓存:新的 PHP-FPM 主进程或 CLI 进程直接加载已编译的脚本,不必重新编译。在构建时预先填充它。
opcache.preload 可选 在服务器启动时一次性链接生成的类,见 预加载。
realpath_cache_size / realpath_cache_ttl 4096K / 600 在 validate_timestamps=1 时:每次 include 的路径查找更少。

生成的代码是普通的 PHP,和应用的其余部分一样由 JIT 编译。典型的 Web 请求把时间花在大量短调用上,JIT 在这种场景下收益不大,所以启用之前先测量。

生成的文件都是普通的类声明,因此预构建的缓存可以被预加载。--preload 会为它所构建的缓存写出 opcache.preload 脚本:缓存目录中的 _preload.php,或者由 --preload=FILE 指定的文件。

终端窗口
vendor/bin/aspect cache:warmup:aop public/index.php --workers=$(nproc) --preload
opcache.ini
opcache.preload=/app/var/cache/aop/_preload.php
opcache.preload_user=www-data

不带值的 --preload 必须放在 loader 参数之后,否则它会把 loader 当作自己的值。

PHP-FPM 启动时,这个脚本会 require Composer 的自动加载器,把生成类的类映射交给它,然后把每个已编译的类、它的代理,以及缓存已知的每个未转换类链接进 OPcache。

  • Composer 的 files 自动加载项(辅助函数、polyfill 引导文件)不会被预加载。请求照常 include 它们。
  • 脚本中没有任何绝对路径。和元数据文件一样,一切都通过 __DIR__ 定位,所以随应用一起移动的缓存依然有效。
  • 它列出的恰好是构建时所用缓存中的类。随缓存一起重建它。
  • 预加载时无法链接的类(缺少某个可选依赖)会写入错误日志,交给请求的自动加载器处理。
  • 在静态初始化上带有 behavior 的类同样交给自动加载器:这个 behavior 需要内核,所以由请求来加载它。

每个请求仍然会初始化内核;只是自动加载器再也不必加载那些已经预加载的类。在基准测试中,预加载把每个请求 include 的文件从 517 个减少到 174 个,hot 请求从 5.2 ms 降到 4.9 ms,服务器启动后的第一个请求从 71 ms 降到 24 ms(配合预先填充的文件缓存为 10 ms)。

预加载的类只有在 PHP-FPM 重启后才会改变,而容器本来就是这样部署的。除非设置了 opcache.enable_cli=1,CLI 中不会预加载任何内容。

把框架的缓存构建进镜像。这样每个容器启动时都带着完整的只读缓存,每个副本提供完全相同的生成代码,任何 pod 都不会触发编译。shop demo 以可运行镜像的形式提供了这套配置。

Dockerfile
FROM php:8.5-fpm
# OPcache is part of PHP 8.5, no docker-php-ext-install needed
COPY docker/opcache.ini /usr/local/etc/php/conf.d/opcache.ini
COPY --from=composer:2 /usr/bin/composer /usr/bin/composer
WORKDIR /app
COPY composer.json composer.lock ./
RUN composer install --no-dev --no-scripts --no-autoloader --prefer-dist
COPY . .
RUN composer dump-autoload --no-dev --classmap-authoritative
# 1. The framework's cache: generated classes, proxies, behavior caches, metadata, owned by the user that serves it
# (cache files get the `cacheFileMode` kernel option, by default 0770 minus the umask)
RUN rm -rf var/cache/aop \
&& php vendor/bin/aspect cache:warmup:aop public/index.php --workers="$(nproc)" --preload \
&& chown -R www-data:www-data var/cache/aop \
&& chmod -R a-w var/cache/aop
# 2. The OPcache file cache: a new PHP-FPM master loads compiled scripts instead of compiling them.
# Built in the final image, as the file cache belongs to this PHP build and these paths.
RUN mkdir -p /var/cache/opcache \
&& php -d opcache.enable_cli=1 -d opcache.file_cache_only=1 -d opcache.file_cache=/var/cache/opcache \
vendor/bin/aspect cache:warmup:opcache public/index.php --file-cache=/var/cache/opcache --entry=public/index.php \
&& chown -R www-data /var/cache/opcache
USER www-data

cache:warmup:opcache 会编译应用加载的所有内容:框架的缓存(生成的文件、代理、behavior class 缓存和元数据)、Composer 的类映射和自动加载的文件、包含路径下未被编译的源码、loader 文件,以及用 --entry 指定的入口文件。

  • 只有以 opcache.enable_cli=1、opcache.file_cache_only=1 和 opcache.file_cache=DIR 启动的进程,才会把编译后的脚本写到磁盘。这些设置无法在运行时修改。命令会检查它们,并检查 --file-cache=DIR 是否就是配置的目录;否则会打印出需要运行的确切命令。
  • 框架的缓存、loader 和入口文件必须能够编译,否则命令失败。Composer 类映射中无法编译的文件(例如为更新版本的 PHP 编写的 vendor 测试桩)会被列出并跳过;PHP 会记录编译错误。
  • 在 cache:warmup:aop 之后、在最终镜像中、用处理请求的那个 PHP 二进制文件运行它。文件缓存以 PHP 构建和文件的绝对路径为键。
docker/opcache.ini
opcache.enable=1
opcache.memory_consumption=192
opcache.interned_strings_buffer=32
opcache.max_accelerated_files=50000
opcache.validate_timestamps=0
opcache.file_cache=/var/cache/opcache
opcache.file_cache_consistency_checks=0
; PHP 8.5: the primed file cache is only read at runtime, also on a read-only root file system
opcache.file_cache_read_only=1
; required on PHP 8.5.11 / 8.5.12, see "JIT"
opcache.jit=disable
; optional, see "Preloading" (written by cache:warmup:aop --preload)
; opcache.preload=/app/var/cache/aop/_preload.php
; opcache.preload_user=www-data

镜像中的内核就是 检查清单 里的生产内核:debug => false,includePaths 只限于 src/,外加 Features::PREBUILT_CACHE。

在基准测试中,这套配置让刚启动的服务器在使用文件缓存时 19 ms 处理完第一个请求,在文件缓存加预加载时只需 10 ms,而两者都不用时为 71 ms。pod 从第一个请求起就很快。

  • 只读根文件系统(readOnlyRootFilesystem: true)。PREBUILT_CACHE 读取构建进镜像的缓存,运行时不写入任何内容。
  • 一个镜像,一份缓存。 把缓存放在镜像里,而不是共享卷上,这样每个版本提供的正是它构建时的代码。
  • 滚动更新不需要任何特殊处理。新 pod 带来自己的缓存,旧 pod 保留它们的缓存。
  • 当镜像无法包含缓存时,在 init 容器中运行 cache:warmup:aop,写入一个 emptyDir 卷,并把这个卷挂载到应用容器的缓存路径上。这样仍然可以使用 PREBUILT_CACHE,pod 就绪时缓存已经完整。
  • CLI 容器(队列消费者、cron 任务)使用同一个镜像和缓存。将 opcache.enable_cli=1 与预先填充的 opcache.file_cache 一起启用,见 CLI 进程。

常驻 worker(RoadRunner、FrankenPHP worker 模式、Swoole、ReactPHP)每个 worker 只启动一次内核。Call context 在请求之间一直保持已初始化的状态。

  • 精确定位。 只有匹配的成员会被拦截,只有匹配的类会被编译,所以精确的规则就是快的规则。execution(public App\Service\*->*(*)) 也会匹配构造函数。不需要它们时,加上 && !execution(**->__construct(*))。
  • 优先使用方法规则,而不是 initialization(...)。 只要注册了 initialization 规则,生成文件中的每个 new 都会经过转换器。没有初始化 behavior(且构造函数为 public)的类仍然通过原生 new 创建,比普通的 new 大约多花 130 ns。带有初始化 behavior 的类则会走完整的 call context。
  • 惰性注册 behavior class,使用 addLazyService()。Behavior class 及其依赖在第一次 behavior 调用时才创建,而不是每个请求都创建。
  • 让 behavior 保持轻量。 getMethod() 和 getField() 在每个 call context 首次使用时创建一个反射对象。从中一次性取出注解或名称,以 class::method 为键保存在 behavior class 中。
  • 惰性格式化 call context。 (string) $invocation 每次调用都会构建一个字符串。只在真正要写出的消息中使用它。
  • 原生 include。 Features::INTERCEPT_INCLUDES 让生成文件中的 include/require 经过编译器,用于不由 Composer 加载的遗留代码。启用它之后,在生产环境中 include 一个缓存已知的文件时,会直接通过其原始路径或缓存路径提供,不经过流过滤器(每次 include 约 250 µs → 约 11 µs)。

一个惰性注册的 behavior class:

src/ApplicationAspectKernel.php
use Go\Core\AspectContainer;
use Go\Core\AspectKernel;
use Psr\Log\LoggerInterface;
class ApplicationAspectKernel extends AspectKernel
{
protected function configureAop(AspectContainer $container): void
{
// Runs when one of its behaviors first runs, after the application container is attached
$container->addLazyService(
MonitorAspect::class,
static fn(AspectContainer $container) => new MonitorAspect($container->getService(LoggerInterface::class)),
);
}
}

如何编写 behavior 和 matching rule,见 行为与匹配规则。

消息或现象 含义与处理方法
cache:warmup:aop 向 stderr 写出错误,并以非零退出码退出 有文件无法编译。部署或 docker build 会停下,这样就永远不会发布不完整的缓存。修复该文件后重新运行预热。
WeavingException:... is missing from the prebuilt AOP cache in ... 启用 PREBUILT_CACHE 时,包含路径下的某个类或被 include 的文件在缓存中没有记录,或者它的缓存文件已经不存在。用 cache:warmup:aop 重建缓存。
cache:warmup:opcache 打印出一条命令,而没有预填充缓存 进程不是以 -d opcache.enable_cli=1 -d opcache.file_cache_only=1 -d opcache.file_cache=DIR 启动的,或者 --file-cache 指定的是另一个目录。运行打印出的命令。

PHP 只在 PHP-FPM 主进程(或 php -S)启动时报告一次预加载问题,写在它的错误日志中。

消息 含义与处理方法
Fatal Error "opcache.preload" requires "opcache.preload_user" when running under uid 0 主进程以 root 身份运行。把 opcache.preload_user 设为运行 worker 的用户(www-data)。
Failed opening required '.../_preload.php' 脚本不存在:构建缓存时没有加 --preload,或者 opcache.preload 指向了另一个缓存目录。用 cache:warmup:aop --preload 重新构建。
Go! AOP preload: <class> is left to the autoloader: ... 脚本无法加载缓存中的某个类,多半是因为没有安装某个可选依赖(--no-dev 镜像)。无害:这个类不会被预加载,需要它的请求照常自动加载。
Can't preload unlinked class <class>: Unknown parent/trait/interface <name> in <file> OPcache 无法链接预加载所 include 的某个文件中的类,原因同上。对于缓存中的类,它会和上一行一起出现。无害:这个类只是没有被预加载。
vendor 辅助文件中的 Can't preload unlinked class class@anonymous: Unknown trait ... 来自 Composer files 自动加载文件的匿名类,例如 Laravel 的 Illuminate/Reflection/helpers.php。缓存的脚本不包含这些文件;这个警告来自另一个在它之前 require 了 vendor/autoload.php 的脚本。先 require 缓存的脚本:这样 Composer 会直接返回它的加载器,不会再次 include 这些文件。

应用、基准测试脚本和 Docker 镜像都在 goaop/shop-demo 中。一个脚本即可复现本页的所有表格:

终端窗口
bash bench/run-all.sh
  • 应用: 约 45 个手写的类(领域、仓储、服务、控制器、内存中的基础设施)、40 个生成的模块(服务和仓储被编译;DTO、验证器和事件不被编译),以及包含路径之外的 120 个库类。
  • Behavior class: 日志(注解上的 #[Before])、缓存和事务(注解上的 #[Around])、监控(仓储上的 #[Around],服务上的 #[AfterThrowing])、库存审计(属性上的 #[Around])、安全(模块服务上的 #[Before])。
  • 基线: 不带内核的同一份代码。其中的 behavior 不会运行。
  • 运行时: PHP 8.5.12 NTS,4 个 CPU,OPcache 设置 opcache.jit=disable 和 opcache.file_update_protection=0。
  • Web 请求: 内置 Web 服务器(php -S,一个 worker,OPcache 共享内存在请求之间保留)。warm 指新启动服务器的第一个请求(7 个样本);hot 指 350 个请求的中位数。时间在脚本内部用 hrtime() 测量。
  • 性能分析: 用 Xdebug 3.5 的 xdebug.mode=profile 对每种模式和状态各运行一次,用于统计调用次数和时间分布。耗时数据来自不带 Xdebug 的运行。

能推广到其他机器上的,是各模式之间的比例。

© 2026 Alexander Lisachenko