PHP垃圾回收机制：深入解析与优化策略
*本文将从 PHP 内存管理与垃圾回收（Garbage Collection, GC）的基础原理出发，深入剖析 PHP 内置的垃圾回收机制在何种场景下工作，如何手动或自动触发回收，以及如何优化程序中可能出现的内存泄漏问题。
目录
1. PHP 内存管理概览
在深入垃圾回收机制之前，先了解 PHP 内存管理的整体架构：
- 内存分配（Memory Allocation）：当程序中创建变量、数组、对象等时，Zend 引擎会从进程的堆（Heap）或内部 ZEND\_MM（Zend 内存管理器）中分配一块内存；
- 引用计数（Reference Counting）：PHP 对数组、对象、字符串等“复杂类型”使用引用计数：记录每个 zval（Zend Value，PHP 变量的底层结构）被多少“引用”所使用；
- 垃圾回收（Garbage Collection）：当 zval 的引用计数归零时，其占用内存可以立即释放；但对于循环引用（A 引用 B，B 引用 A），即使计数都大于 0，也无法被释放。Zend GC 专门用于检测并清理这类“孤立环路”。
1.1 PHP 内存使用示例
<?php
// 1. 创建普通标量，直接在栈上分配（小于 ZEND_MM_THRESHOLD），无需 GC
$a = 123;
$b = "Hello, World!";
// 2. 创建数组，数组底层为 HashTable，属于复杂类型
$arr = [1, 2, 3, 4];
// 3. 创建对象，zval 存储了对象句柄（object id），实际数据在堆上
class Foo { public $x = 10; }
$obj = new Foo();
// 4. 引用赋值，$c 指向同一个 zval，引用计数增加
$c = $arr;
// 5. unset($arr) 后，数组引用计数减 1；如果计数归零，则 zval 对应的 HashTable 可被销毁
unset($arr);
// 6. 对象循环引用（需 GC 清理）
$a = new stdClass();
$b = new stdClass();
$a->ref = $b;
$b->ref = $a;
// 即使 unset($a) 和 unset($b)，由于循环引用存在，引用计数都不为 0，需要 GC 清理
unset($a, $b);
?>以上示例中，第 6 步会产生“循环引用”场景。只有在 PHP 开启垃圾回收后，Zend GC 才能主动识别并清理这段无用内存，否则会持续占用，导致内存泄漏。
2. 引用计数（Reference Counting）机制
2.1 引用计数的基本原理
PHP 内部对以下数据类型均使用引用计数：
array（数组）；object（对象）；string（字符串；如果字符串长度较短也可能采用 Copy-on-Write，但底层 zval 仍维护引用计数）；- 资源（如
PDO实例、文件句柄等，对应底层资源结构也可能带引用计数）；
引用计数（refcount）维护要点：
- 当变量首次被赋值时，Zend 会将对应 zval 的
refcount设为 1； - 当进行类似
$b = $a;的赋值操作时，不会“复制”整个数据结构，而是让$b指向同一个 zval，同时将refcount自增； - 当调用
unset($var)或者$var = null;时，Zend 会将对应 zval 的refcount自减； - 如果
refcount变为 0，表明没有任何变量再引用此 zval，Zend 会立即释放 zval 占用的所有内存。
代码示例：引用计数演示
<?php
$a = [1, 2, 3]; // 新建数组 zval，refcount = 1
$b = $a; // $b 引用同一个数组，refcount = 2
$c = &$a; // 引用赋值，$c 与 $a 同为引用，refcount = 2（未增加）
unset($a); // $a 引用去除，refcount = 1（仍被 $b 引用）
$b = null; // $b 引用去除，refcount = 0，立即释放数组内存
?>说明：
- 上述
$c = &$a;为引用赋值（alias），与$b = $a;不同：$b = $a;只是让$b指向同一份 zval，并不算 alias。而$c = &$a;会让$c与$a变成“同一个符号表条目”，它们对 zval 的引用计数无变化。
2.2 示意图：引用计数如何工作
Step 1: $a = [1, 2, 3]
+--------------------+
zval[A] = | HashTable: [1,2,3] | refcount = 1
+--------------------+
a ──► zval[A]
Step 2: $b = $a
+--------------------+
zval[A] = | HashTable: [1,2,3] | refcount = 2
+--------------------+
a ──┐
└─► zval[A] (同上)
b ──► zval[A]
Step 3: unset($a)
+--------------------+
zval[A] = | HashTable: [1,2,3] | refcount = 1
+--------------------+
b ──► zval[A]
Step 4: $b = null; // refcount 由 1 变为 0，数组内存被立即释放2.3 引用计数的局限性：循环引用问题
单纯的引用计数策略无法处理循环引用。以下示例展示最典型的循环引用场景：
<?php
class Node {
public $ref;
}
// 创建两个对象，它们互相引用
$a = new Node(); // zval[A]，refcount = 1
$b = new Node(); // zval[B]，refcount = 1
$a->ref = $b; // zval[B].refcount++ → refcount[B] = 2
$b->ref = $a; // zval[A].refcount++ → refcount[A] = 2
unset($a); // zval[A].refcount-- → refcount[A] = 1
unset($b); // zval[B].refcount-- → refcount[B] = 1
// 由于 refcount[A] = 1（被 zval[B]->ref 引用）
// refcount[B] = 1（被 zval[A]->ref 引用），
// 且没有任何外部引用能访问到它们，内存却无法被释放 → 内存泄漏此时，只有**Zend GC（循环检测机制）**才能识别这两个对象互相引用的孤立循环，并将之回收。
3. PHP Zend 垃圾回收（Zend GC）机制
PHP 5.3.0 及更高版本内置了“循环引用垃圾回收器（GC）”，它在引用计数之外，定期扫描可能存在循环引用的 zval 容器（如数组、对象），并清理不再被外部引用的环路。
3.1 Zend GC 的触发时机与原理
触发时机
PHP 在执行内置操作时会随机触发一次垃圾回收，触发概率由
gc_probability与gc_divisor两个配置参数决定：zend.enable_gc = On zend.gc_probability = 1 zend.gc_divisor = 1000当 PHP 需要为新的 zval 分配内存且该分配操作触发了一个随机数判断（
rand(1, gc_divisor) <= gc_probability），便会执行一次 Zend GC。- 同时，开发者可以在任意时刻，通过调用
gc_collect_cycles()强制触发一次 GC，立即扫描当前所有可能的循环引用并清除。
原理概览
- 收集可能的“标记列表（Root Buffer）”：Zend 在所有涉及引用计数的 zval 容器（数组、对象）登记它们的 zval 地址，形成一个“候选列表”，称为 root buffer。
标记扫描：Zend GC 会对 root buffer 中的每个“候选 zval”进行一次标记：
- 如果该 zval 的 引用计数（
refcount） > 0，Zend GC 会将其视为“外部可达”，并递归地标记其内部所引用的其他 zval； - 如果某个 zval 接受标记，Zend 不会将其纳入需要删除的列表；
- 如果该 zval 的 引用计数（
- 清除不可达环：在扫描完成后，如果某 zval 在整个“标记阶段”都未被标记为可达，意味着它属于一种“循环引用，但没有任何外部变量指向它们”的孤立环路，可以安全回收，此时 Zend GC 会将这些 zval 一次性销毁。
- 重置标记并继续执行：完成一次扫描后，Zend GC 会清空标记状态，为下次触发做准备。
注意：
- Zend GC 只处理
refcount > 0且位于 root buffer 中的 zval（也即“可能存在循环引用”的复杂类型）。- 对于标量类型（如整型、浮点、布尔等），PHP 并不会纳入 GC 范畴，因为它们直接在栈或寄存器中存储，不会产生循环引用问题。
3.2 Zend GC 工作流程示意图
+-------------------------------------------------------------+
| PHP 引擎执行上下文（Userland） |
| |
| ↓ 在为新 zval 分配内存时，根据概率决定是否触发 GC |
| |
+-------------------------------------------------------------+
│ │
│触发 │不触发
▼ │
+-------------------------------------------------------------+
| Zend 垃圾回收器（GC） |
| |
| 1. 遍历 root buffer（候选列表） |
| ├─ 对每个 zvalIf (refcount > 0) 且未标记，则标记为“可达” |
| | 并递归标记其引用到的所有 zval |
| └─ 否则该 zval 可能是“孤立环” |
| |
| 2. 遍历 root buffer 中所有 zval，找出仍未标记的“孤立环” |
| └─ 将这部分 zval 从内存中销毁：释放 HashTable、对象属性等 |
| |
| 3. 清空所有 zval 的标记状态，退出 GC |
+-------------------------------------------------------------+
▲
│
│
+-------------------------------------------------------------+
| 触发时机：gc_probability / gc_divisor 概率随机触发 |
| 或者开发者调用 gc_collect_cycles() 强制触发 |
+-------------------------------------------------------------+3.3 gc_enabled()、gc_collect_cycles() 等函数详解
1. gc_enabled()
bool gc_enabled ( void )返回值：
true：GC 功能已启用 (zend.enable_gc = On)；false：GC 功能被禁用 (zend.enable_gc = Off)；
2. gc_enable() / gc_disable()
void gc_enable ( void ); // 开启 GC（仅对本次请求有效）
void gc_disable ( void ); // 关闭 GC（仅对本次请求有效）- 可在脚本运行中动态开启或关闭 GC。例如在性能敏感的循环中临时禁用 GC，然后在循环结束后手动调用
gc_collect_cycles()进行一次集中回收。
3. gc_collect_cycles()
int gc_collect_cycles ( void )- 功能：立即触发一次 Zend GC，扫描当前潜在的循环引用并清除；
- 返回值：清除的 zval 数量（循环节点数）；如果 GC 功能被禁用或无可清除节点，返回 0。
示例：手动触发 GC
<?php
// 假设 zend.enable_gc = On
echo "GC enabled? " . (gc_enabled() ? "Yes" : "No") . PHP_EOL;
// 关闭 GC
gc_disable();
echo "After disable, GC enabled? " . (gc_enabled() ? "Yes" : "No") . PHP_EOL;
// 某段逻辑：创建大量循环引用
$a = new stdClass();
$b = new stdClass();
$a->ref = $b;
$b->ref = $a;
// 手动触发：由于 GC 被禁用，以下调用无效，返回 0
$collected = gc_collect_cycles();
echo "Collected cycles (disabled): $collected" . PHP_EOL;
// 重新开启 GC
gc_enable();
echo "After enable, GC enabled? " . (gc_enabled() ? "Yes" : "No") . PHP_EOL;
// 再次触发：成功清除循环引用，返回值通常为 2（两个 zval 节点被删除）
$collected = gc_collect_cycles();
echo "Collected cycles (enabled): $collected" . PHP_EOL;
?>3.4 gc_probability 与 gc_divisor 配置参数
在 php.ini 中，以下配置控制自动触发 GC 的概率：
; 启用/禁用垃圾回收
zend.enable_gc = On
; 当 PHP 分配第 N 个 zval 时，随机数判断是否触发 GC
; 触发概率 = gc_probability / gc_divisor
zend.gc_probability = 1
zend.gc_divisor = 1000- 默认配置表示：每次新的 zval 分配时，PHP 会生成一个范围在 1 到
gc_divisor（即 1000）之间的随机数；如果随机数 ≤gc_probability（即 1），则触发一次 GC。 - 举例：
gc_probability = 3, gc_divisor = 100→ 触发概率 = 3%。
优化建议：
- 对于短生命周期、无明显循环引用的脚本，可将
gc_enabled = Off，或调小触发概率，以牺牲一定的内存占用换取微弱的性能提升；- 对于长周期运行的守护进程（如 Swoole、Worker 进程），建议保持 GC 打开，同时增大
gc_probability以减少循环引用内存占用。
4. 常见内存泄漏场景与示例
尽管 Zend GC 能清理绝大多数孤立循环，但在以下场景下仍需我们格外留意，及时手动回收或重构代码。
4.1 示例 1：简单循环引用造成的泄漏
<?php
class A {
public $ref;
}
class B {
public $ref;
}
// 创建循环引用
$a = new A(); // zval[A], refcount = 1
$b = new B(); // zval[B], refcount = 1
$a->ref = $b; // zval[B] refcount = 2
$b->ref = $a; // zval[A] refcount = 2
unset($a); // zval[A] refcount = 1
unset($b); // zval[B] refcount = 1
// 经过 unset 后，没有任何外部变量引用这两个对象，
// 但由于它们互相引用，refcount 仍为 1，无法立即释放。
// 如果 Zend GC 没触发，内存持续占用。
echo "Memory usage before GC: " . memory_get_usage() . PHP_EOL;
// 手动触发 GC
$collected = gc_collect_cycles();
echo "Collected cycles: $collected" . PHP_EOL;
echo "Memory usage after GC: " . memory_get_usage() . PHP_EOL;
?>输出示例：
Memory usage before GC: 123456 bytes
Collected cycles: 2
Memory usage after GC: 23456 bytes说明：
- 手动调用
gc_collect_cycles()后，隐式清理了这两个互相引用的对象；- 若未调用手动 GC，则直到下一次 PHP 自动触发或者请求结束后，才会回收这段内存。
4.2 示例 2：闭包（Closure）捕获对象导致的引用链
PHP 中，闭包函数可以捕获外部变量，若闭包与对象互相引用，也会形成循环：
<?php
class User {
public $name;
public $callback;
public function __construct($name) {
$this->name = $name;
}
}
// 创建对象 $u
$u = new User("Alice");
// 创建闭包并将其赋给 $u->callback，闭包内部引用了 $u，本身 $u 又引用了闭包 → 形成循环
$u->callback = function() use ($u) {
echo "Hello, {$u->name}\n";
};
unset($u);
// 此时闭包对象与 User 对象保持循环，但没有被外部引用，
// 需要 GC 去检测并清理
echo "Before GC: memory = " . memory_get_usage() . PHP_EOL;
gc_collect_cycles();
echo "After GC: memory = " . memory_get_usage() . PHP_EOL;
?>图解说明：
+----------------+ +----------------+ | zval[User:u] | —ref-> | zval[Closure] | | name="Alice" | uses $u | | callback=Closure |<--ref--+ | +----------------+ | | | +--------+ | （Closure use 捕获）
- 如上所示，
zval[User:u]与zval[Closure]互相引用；- 仅当 GC 触发时，才能将两者清理。
4.3 示例 3：静态属性与单例模式中的内存积累
在某些高并发、长期运行的 CLI/Daemon 脚本中，若频繁使用单例模式、并将大量数据存储在静态属性或全局变量中，却从未清理，易造成内存持续增长：
<?php
class Cache {
private static $instance = null;
private $data = [];
private function __construct() { }
public static function getInstance() {
if (self::$instance === null) {
self::$instance = new Cache();
}
return self::$instance;
}
public function set($key, $value) {
$this->data[$key] = $value; // 持久保存，永不释放
}
public function get($key) {
return $this->data[$key] ?? null;
}
}
// 模拟任务循环
for ($i = 0; $i < 100000; $i++) {
$cache = Cache::getInstance();
$cache->set("item$i", str_repeat("x", 1024)); // 不断往 data 中填充 1KB 数据
if ($i % 1000 === 0) {
echo "Iteration $i, memory: " . memory_get_usage() . PHP_EOL;
}
// 永远不会释放单例中的数据，内存持续增长
}
?>优化思路：
- 定期清理或缩减
$data数组长度，例如只保留最近 N 条数据；- 避免将短期临时数据存入静态属性，改用局部变量或外部缓存（如 Redis）。
5. 手动触发与调优垃圾回收
采购合适的 GC 策略，可以在性能与内存占用之间取得良好平衡。以下方法可帮助你针对不同场景进行优化。
5.1 手动检查 GC 是否启用：gc_enabled()
<?php
if (gc_enabled()) {
echo "垃圾回收已启用\n";
} else {
echo "垃圾回收已禁用\n";
}
?>- 在某些高性能场景中，可在脚本开头根据配置或环境动态调用
gc_disable()，而在需要时再开启。
5.2 强制触发垃圾回收：gc_collect_cycles()
<?php
// 在长循环后阶段或业务处理完成后，主动触发循环引用回收
$collected = gc_collect_cycles();
echo "本次回收了 $collected 个循环引用节点（zval）\n";
?>最佳实践：
- 在脚本中执行完一个大任务/循环后，调用
gc_collect_cycles()； - 在单次请求结束时，无需手动调用，PHP 请求结束时会自动回收；
- 在 CLI 长驻脚本（如 Swoole、Workerman）中，应根据实际内存占用情况判断是否调用。
- 在脚本中执行完一个大任务/循环后，调用
5.3 配置 gc_probability 与 gc_divisor 优化触发频率
打开
php.ini或使用ini_set动态调整：<?php ini_set('zend.enable_gc', '1'); // 启用 GC ini_set('zend.gc_probability', '5'); // 提高触发概率 ini_set('zend.gc_divisor', '100'); // 将触发概率设置为 5% ?>- 在高并发短生命周期脚本中，可将触发概率调小；
- 在长驻进程中，可将触发概率调大，以便更频繁清理循环引用。
5.4 示例：动态调整 GC 策略以优化内存占用
<?php
// 例如一个 CLI 脚本，需要根据运行时内存占用动态开启/禁用 GC
function monitor_memory_and_adjust_gc() {
$mem = memory_get_usage(true); // 获取真实占用
if ($mem > 50 * 1024 * 1024) { // 如果占用 > 50MB
if (!gc_enabled()) {
gc_enable();
echo "内存已超 50MB，开启 GC\n";
}
// 主动回收一次
$collected = gc_collect_cycles();
echo "主动回收了 $collected 个循环引用节点\n";
} else {
if (gc_enabled()) {
gc_disable();
echo "内存在安全范围内，关闭 GC 提升性能\n";
}
}
}
// 模拟长循环任务
for ($i = 0; $i < 100000; $i++) {
// 生产模拟循环引用
$a = new stdClass();
$b = new stdClass();
$a->ref = $b;
$b->ref = $a;
unset($a, $b);
if ($i % 1000 === 0) {
monitor_memory_and_adjust_gc();
}
// 业务逻辑...
}
?>在该示例中，脚本每处理 1000 个循环后，检查当前内存占用：
- 如果超过 50MB，则确保 GC 已开启并手动触发一次；
- 如果低于阈值，则关闭 GC，减少不必要的回收开销。
6. 通用优化策略与最佳实践
在理解了 PHP 内置垃圾回收机制之后，还需结合实际业务场景，采取以下优化策略，以减少内存泄漏、提升性能。
6.1 避免不必要的循环引用
- 尽量不让对象互相引用，尤其是在对象之间用 Array 存储引用时；
- 若必须产生循环引用，可在循环末端处显式
unset($a->ref)或调用析构函数进行中断；
示例：避免循环引用
<?php
class ParentObj {
public $child;
public function __destruct() {
// 当父对象销毁时，显式断开与 child 的引用
unset($this->child);
}
}
class ChildObj {
public $parent;
public function __destruct() {
unset($this->parent);
}
}
$p = new ParentObj();
$c = new ChildObj();
$p->child = $c;
$c->parent = $p;
// 当脚本运行结束或主动销毁 $p 时，
// 由于 __destruct() 显式 unset，循环引用被中断，便于引用计数归零
unset($p);
unset($c);
?>- 通过在析构方法中显式断开循环引用，可以让引用计数直接归零，减少对 Zend GC 的依赖。
6.2 及时销毁不再使用的资源
- 对于数据库连接、文件句柄、大型数组等临时占用大量内存的资源，应在不再需要时立即
unset()或调用相应的关闭/销毁方法； - 避免将大数据缓存在全局静态变量或单例中，保证它能被及时回收。
示例：立即销毁大型数组
<?php
function processLargeDataset() {
$data = [];
for ($i = 0; $i < 100000; $i++) {
$data[] = str_repeat('x', 1024); // 每条约 1KB 数据
}
// 处理数据...
echo "处理完成，内存： " . memory_get_usage() . PHP_EOL;
// 立即释放 $data 占用
unset($data);
// 建议在此强制触发 GC，清理潜在循环引用
gc_collect_cycles();
echo "释放后内存： " . memory_get_usage() . PHP_EOL;
}
processLargeDataset();
?>6.3 使用弱引用（Weak Reference）
PHP 7.4 引入了 Weak Reference（弱引用）功能，用于在不增加引用计数的情况下引用一个对象。如果仅需要观察对象状态而不想影响其回收，可以使用 WeakReference 类。
示例：WeakReference 用法
<?php
class Foo {
public $data = "some data";
}
$foo = new Foo();
$weakRef = WeakReference::create($foo);
// 此时 $weakRef 持有对 $foo 的弱引用，不会增加 $foo 的引用计数
echo "WeakRef get: ";
var_dump($weakRef->get()); // object(Foo)
unset($foo); // 销毁 $foo，弱引用不会阻止 $foo 被回收
echo "After unset, WeakRef get: ";
var_dump($weakRef->get()); // NULL
?>场景：
- 缓存系统：当缓存对象不再被外部持有时，希望它能被自动销毁；
- 观察者模式：监听者仅需临时获取对象状态，但不想因为监听而阻止对象被回收。
6.4 对长生命周期脚本进行内存监控与剖析
- 对于常驻内存的 PHP 进程（如 Swoole Server、Worker 进程），务必定期监控内存占用情况；
使用工具：
- Xdebug：可生成内存使用快照（Memory Snapshot），并图形化展示变量和对象的内存占用；
- memory\_get\_usage() / memory\_get\_peak\_usage()：在合适的位置打印当前/峰值内存，判断是否有持续增长趋势；
- 第三方扩展：如
Meminfo扩展，能打印出当前内存占用的详细分布（包括每个对象和数组的占用）。
6.5 升级至 PHP 7+ 版本获取更优的整体性能
- PHP 7 对“内存分配器（Zend Memory Manager）”进行了大量优化，使得小对象的内存分配与释放更高效；
- Zend GC 在 PHP 7.3+ 进一步优化，提升循环检测速度；
- 如果应用尚在 PHP 5.6 或更早版本，强烈建议升级到 PHP 7.4 或 8.x，以获得更快的性能和更优的内存占用表现。
7. 实战：Web 应用内存泄漏检测和修复
以下示例展示如何在一个典型的 Web 请求处理流程中，通过 Xdebug 快照和内存日志定位、修复内存泄漏。
7.1 使用 Xdebug 和 Memory Profiler
安装并开启 Xdebug，并在
php.ini中添加：xdebug.mode = debug,profile xdebug.start_with_request = yes xdebug.output_dir = /path/to/xdebug/profiles在请求入口处（如
index.php）添加：<?php ini_set('xdebug.profiler_enable', 1);这样每次请求会生成一个
.cachegrind文件，可用 KCacheGrind、QCacheGrind 等可视化工具查看内存分配图。- 根据可视化报告，找到内存占用最多的函数或文件行，重点检查这些代码是否有循环引用或未释放的全局变量。
7.2 示例：定位某个请求处理过程中的内存峰值
<?php
// index.php
ini_set('xdebug.profiler_enable', 1);
require 'bootstrap.php'; // 加载框架或初始化
// 处理某个业务逻辑
$data = getLargeDataFromDatabase(); // 假设返回一个大数组
processDataAndCache($data); // 处理并缓存在 Session 或静态属性
// 渲染模板
render('template.phtml', ['data' => $data]);- 启动请求后，Xdebug 会在
/path/to/xdebug/profiles生成一个cachegrind.out.*文件； - 用可视化工具打开，查看“memory usage”排名靠前的函数，比如
processDataAndCache、render等； - 如果在
processDataAndCache中将$data存储到一个全局静态变量或 Session 中，就可能造成后续请求再次加载时重复占用内存，进而出现“内存泄漏”现象。
7.3 分析日志：找出增长最快的变量或对象
除了 Xdebug，还可在代码里分段打印
memory_get_usage(true)和memory_get_peak_usage(true)，查看哪些步骤内存增长最明显：<?php $startMem = memory_get_usage(true); $data = getLargeDataFromDatabase(); echo "After DB fetch: " . (memory_get_usage(true) - $startMem) . " bytes\n"; $afterProcess = memory_get_usage(true); processDataAndCache($data); echo "After processing: " . (memory_get_usage(true) - $afterProcess) . " bytes\n"; // ... ?>- 结合堆栈分析和代码阅读，快速定位到“哪一步”创建了大量长生命周期变量且未及时释放。
7.4 修复思路：从根源消除循环引用或优化数据结构
重构循环引用代码：
- 将互相持有引用的对象改为弱引用或在析构时断开引用；
- 如果循环引用不可避免，可在
processDataAndCache完成后显式unset($objA->ref); unset($objB->ref);，并调用gc_collect_cycles()。
优化数据缓存策略：
- 尽量不要将大型数组完整存储到 Session、静态变量或全局变量；
- 如果需要缓存，仅保留必要字段，或者将数据分批、分页缓存；
释放中间变量：
- 在循环或大批量处理时，将不用的中间变量置为
null或unset； - 避免多个拷贝同时驻留内存，例如
$b = $a;再操作$b会在底层产生新的拷贝时占用更多内存。
- 在循环或大批量处理时，将不用的中间变量置为
8. 总结
PHP 内存管理 依赖于引用计数和**Zend GC（循环引用检测）**两大机制：
- 引用计数可立即回收
refcount归零的 zval； - Zend GC 用于检测并清理仅存在于循环引用中的无用 zval；
- 引用计数可立即回收
- 循环引用 是造成 PHP 内存泄漏的最常见原因之一，开发者在设计对象间关系时，应尽量避免或手动断开循环；
- 手动触发 GC（
gc_collect_cycles()）和调整 GC 触发概率（gc_probability/gc_divisor）是控制内存占用的重要手段； - 弱引用（Weak Reference） 自 PHP 7.4 起可用于防止因引用计数而导致的内存不可回收；
- 实战中，需要借助 Xdebug、Memory Profiler、memory\_get\_usage() 等工具定位内存瓶颈，并结合“及时销毁资源”与“优化数据结构”等策略进行修复。