PHP 内存管理：深入理解引用和垃圾回收 ​

很多 PHP 开发者对内存管理这块都不太重视，觉得反正 PHP 会自动处理，不用操心。但实际上，不少性能问题都是因为对 PHP 内存机制理解不够造成的。

特别是做高并发项目的时候，内存管理就显得特别重要了。一个小小的内存泄漏，在百万级请求量下可能直接把服务器搞崩，运维成本蹭蹭往上涨。所以搞清楚 PHP 的内存模型，不是为了装逼，而是写出靠谱代码的基本功。

PHP 如何管理内存 ​

PHP 通过引用计数和垃圾回收实现自动内存管理。与 C 语言需要手动分配和释放内存不同，PHP 自动处理这些，但理解其机制有助于编写更高效的代码。

引用计数基础 ​

PHP 使用引用计数系统来跟踪有多少变量正在引用特定值：

php
// 理解引用计数
$var1 = "Hello World";  // 创建字符串，引用计数 = 1
$var2 = $var1;          // 复制值，引用计数 = 2
$var3 = &$var1;         // 创建引用，引用计数 = 3

// 使用xdebug查看引用计数
xdebug_debug_zval('var1');
/*
输出:
var1: (refcount=3, is_ref=1)='Hello World'
*/

unset($var2);           // 引用计数减少到2
unset($var3);           // 引用计数减少到1
unset($var1);           // 引用计数减少到0，内存被释放

PHP 中的内存分配 ​

php
// 不同数据类型使用不同的内存策略
class MemoryAnalyzer
{
    public function analyzeMemoryUsage(): void
    {
        $this->showMemoryUsage('初始状态');

        // 字符串
        $string = str_repeat('A', 1000000); // 1MB字符串
        $this->showMemoryUsage('创建1MB字符串后');

        // 数组
        $array = range(1, 100000);
        $this->showMemoryUsage('创建10万整数数组后');

        // 对象
        $objects = [];
        for ($i = 0; $i < 10000; $i++) {
            $objects[] = new stdClass();
        }
        $this->showMemoryUsage('创建1万个对象后');

        // 清理
        unset($string, $array, $objects);
        $this->showMemoryUsage('清理后');

        // 强制垃圾回收
        gc_collect_cycles();
        $this->showMemoryUsage('垃圾回收后');
    }

    private function showMemoryUsage(string $stage): void
    {
        $current = memory_get_usage(true);
        $peak = memory_get_peak_usage(true);

        echo sprintf(
            "%-25s: 当前: %s, 峰值: %s\n",
            $stage,
            $this->formatBytes($current),
            $this->formatBytes($peak)
        );
    }

    private function formatBytes(int $bytes): string
    {
        $units = ['B', 'KB', 'MB', 'GB'];
        for ($i = 0; $bytes > 1024 && $i < 3; $i++) {
            $bytes /= 1024;
        }
        return round($bytes, 2) . ' ' . $units[$i];
    }
}

$analyzer = new MemoryAnalyzer();
$analyzer->analyzeMemoryUsage();

理解写时复制（Copy-on-Write） ​

PHP 为数组和对象实现了写时复制（COW）优化：

php
// 写时复制演示
function demonstrateCopyOnWrite(): void
{
    echo "创建数组前的内存: " . memory_get_usage() . "\n";

    $array1 = range(1, 100000);
    echo "创建array1后的内存: " . memory_get_usage() . "\n";

    $array2 = $array1; // 由于COW，此时还没有实际复制
    echo "array2赋值后的内存: " . memory_get_usage() . "\n";

    $array2[50000] = 'modified'; // 现在才发生复制
    echo "修改array2后的内存: " . memory_get_usage() . "\n";

    unset($array1, $array2);
    echo "清理后的内存: " . memory_get_usage() . "\n";
}

demonstrateCopyOnWrite();

循环引用和垃圾回收 ​

PHP 的垃圾回收器专门处理循环引用：

php
// 循环引用示例
class Parent_
{
    public $child;
    public $name;

    public function __construct(string $name)
    {
        $this->name = $name;
    }
}

class Child
{
    public $parent;
    public $name;

    public function __construct(string $name)
    {
        $this->name = $name;
    }
}

function createCircularReference(): void
{
    $parent = new Parent_('父对象');
    $child = new Child('子对象');

    // 创建循环引用
    $parent->child = $child;
    $child->parent = $parent;

    // 即使unset后，由于循环引用，对象也不会被释放
    unset($parent, $child);

    echo "unset后的内存: " . memory_get_usage() . "\n";

    // 垃圾回收器会清理循环引用
    $collected = gc_collect_cycles();
    echo "垃圾回收: $collected 个循环\n";
    echo "GC后的内存: " . memory_get_usage() . "\n";
}

createCircularReference();

内存泄漏和预防 ​

常见的内存泄漏模式及其避免方法：

php
// 内存泄漏示例和修复
class MemoryLeakDemo
{
    private static $cache = [];
    private $callbacks = [];

    // 错误：不断增长的静态缓存，没有清理
    public function badCaching(string $key, $value): void
    {
        self::$cache[$key] = $value; // 永远不会被清理
    }

    // 正确：有大小限制和清理的缓存
    public function goodCaching(string $key, $value): void
    {
        if (count(self::$cache) > 1000) {
            // 移除最旧的条目
            self::$cache = array_slice(self::$cache, 500, null, true);
        }

        self::$cache[$key] = $value;
    }

    // 错误：累积闭包而不清理
    public function badEventListeners(): void
    {
        $this->callbacks[] = function() use (&$this) {
            // 闭包捕获$this，创建潜在的循环引用
            return $this->processData();
        };
    }

    // 正确：适当的闭包清理
    public function goodEventListeners(): void
    {
        $callback = function() {
            return $this->processData();
        };

        $this->callbacks[] = $callback;
    }

    public function cleanup(): void
    {
        $this->callbacks = [];
    }

    private function processData(): string
    {
        return 'processed';
    }
}

// 内存泄漏检测助手
class MemoryLeakDetector
{
    private int $initialMemory;
    private int $peakMemory;

    public function startMonitoring(): void
    {
        $this->initialMemory = memory_get_usage(true);
        $this->peakMemory = memory_get_peak_usage(true);
    }

    public function checkForLeaks(string $operation): void
    {
        $currentMemory = memory_get_usage(true);
        $peakMemory = memory_get_peak_usage(true);

        $memoryIncrease = $currentMemory - $this->initialMemory;
        $peakIncrease = $peakMemory - $this->peakMemory;

        echo "操作: $operation\n";
        echo "内存增长: " . $this->formatBytes($memoryIncrease) . "\n";
        echo "峰值增长: " . $this->formatBytes($peakIncrease) . "\n";

        if ($memoryIncrease > 10 * 1024 * 1024) { // 10MB阈值
            echo "⚠️  检测到潜在内存泄漏！\n";
        }

        echo "\n";
    }

    private function formatBytes(int $bytes): string
    {
        $units = ['B', 'KB', 'MB', 'GB'];
        for ($i = 0; $bytes > 1024 && $i < 3; $i++) {
            $bytes /= 1024;
        }
        return round($bytes, 2) . ' ' . $units[$i];
    }
}

优化内存使用 ​

减少内存消耗的技术：

php
// 内存优化技术
class MemoryOptimizer
{
    // 对大数据集使用生成器
    public function processLargeDataset(): Generator
    {
        // 不要将所有数据加载到内存中
        // 错误: $data = $this->loadAllData();

        // 正确: 使用生成器
        for ($i = 0; $i < 1000000; $i++) {
            yield $this->processItem($i);
        }
    }

    // 批处理以限制内存使用
    public function processBatches(array $items, int $batchSize = 1000): void
    {
        $batches = array_chunk($items, $batchSize);

        foreach ($batches as $batch) {
            $this->processBatch($batch);

            // 显式清理批次数据
            unset($batch);

            // 可选：强制垃圾回收
            if (memory_get_usage() > 100 * 1024 * 1024) { // 100MB阈值
                gc_collect_cycles();
            }
        }
    }

    // 流式文件处理
    public function processLargeFile(string $filename): void
    {
        $handle = fopen($filename, 'r');

        if (!$handle) {
            throw new Exception("无法打开文件: $filename");
        }

        try {
            while (($line = fgets($handle)) !== false) {
                $this->processLine($line);

                // 行在超出作用域时自动清理
            }
        } finally {
            fclose($handle);
        }
    }

    // 优化字符串操作
    public function optimizeStringOperations(): void
    {
        // 错误：在循环中进行字符串连接
        $result = '';
        for ($i = 0; $i < 10000; $i++) {
            $result .= "Item $i\n"; // 每次都创建新字符串
        }

        // 正确：使用数组和implode
        $parts = [];
        for ($i = 0; $i < 10000; $i++) {
            $parts[] = "Item $i";
        }
        $result = implode("\n", $parts);
    }

    // 对频繁创建的对象使用对象池
    private array $objectPool = [];

    public function getObject(): ExpensiveObject
    {
        if (empty($this->objectPool)) {
            return new ExpensiveObject();
        }

        return array_pop($this->objectPool);
    }

    public function returnObject(ExpensiveObject $obj): void
    {
        $obj->reset();
        $this->objectPool[] = $obj;
    }

    private function processItem(int $item): string
    {
        return "处理项目: $item";
    }

    private function processBatch(array $batch): void
    {
        foreach ($batch as $item) {
            // 处理每个项目
        }
    }

    private function processLine(string $line): void
    {
        // 处理行
    }
}

class ExpensiveObject
{
    private array $data = [];

    public function __construct()
    {
        $this->data = range(1, 1000);
    }

    public function reset(): void
    {
        $this->data = range(1, 1000);
    }
}

高级内存管理 ​

php
// 高级内存管理技术
class AdvancedMemoryManager
{
    private SplObjectStorage $storage;
    private array $memorySnapshots = [];

    public function __construct()
    {
        $this->storage = new SplObjectStorage();
    }

    // 跟踪对象内存使用
    public function trackObject(object $obj, string $identifier): void
    {
        $this->storage->attach($obj, [
            'identifier' => $identifier,
            'created_at' => microtime(true),
            'memory_at_creation' => memory_get_usage()
        ]);
    }

    // 分析内存使用模式
    public function analyzeMemoryPattern(): array
    {
        $analysis = [];

        foreach ($this->storage as $obj) {
            $info = $this->storage->getInfo();
            $className = get_class($obj);

            if (!isset($analysis[$className])) {
                $analysis[$className] = [
                    'count' => 0,
                    'total_memory' => 0,
                    'avg_memory' => 0
                ];
            }

            $analysis[$className]['count']++;
            $objectMemory = $this->getObjectMemoryUsage($obj);
            $analysis[$className]['total_memory'] += $objectMemory;
            $analysis[$className]['avg_memory'] =
                $analysis[$className]['total_memory'] / $analysis[$className]['count'];
        }

        return $analysis;
    }

    // 获取对象的大致内存使用量
    private function getObjectMemoryUsage(object $obj): int
    {
        $memoryBefore = memory_get_usage();
        $serialized = serialize($obj);
        $memoryAfter = memory_get_usage();

        return strlen($serialized) + ($memoryAfter - $memoryBefore);
    }

    // 内存快照功能
    public function takeMemorySnapshot(string $label): void
    {
        $this->memorySnapshots[$label] = [
            'timestamp' => microtime(true),
            'memory_usage' => memory_get_usage(true),
            'peak_memory' => memory_get_peak_usage(true),
            'object_count' => count($this->storage)
        ];
    }

    public function compareSnapshots(string $before, string $after): array
    {
        if (!isset($this->memorySnapshots[$before], $this->memorySnapshots[$after])) {
            throw new InvalidArgumentException('快照未找到');
        }

        $beforeSnapshot = $this->memorySnapshots[$before];
        $afterSnapshot = $this->memorySnapshots[$after];

        return [
            'memory_difference' => $afterSnapshot['memory_usage'] - $beforeSnapshot['memory_usage'],
            'peak_difference' => $afterSnapshot['peak_memory'] - $beforeSnapshot['peak_memory'],
            'object_difference' => $afterSnapshot['object_count'] - $beforeSnapshot['object_count'],
            'time_elapsed' => $afterSnapshot['timestamp'] - $beforeSnapshot['timestamp']
        ];
    }

    // PHP 8+的弱引用实现
    public function useWeakReference(object $obj): WeakReference
    {
        return WeakReference::create($obj);
    }

    // 使用弱引用的内存高效缓存
    private array $weakCache = [];

    public function cacheWithWeakReference(string $key, object $obj): void
    {
        $this->weakCache[$key] = WeakReference::create($obj);
    }

    public function getCachedObject(string $key): ?object
    {
        if (!isset($this->weakCache[$key])) {
            return null;
        }

        $obj = $this->weakCache[$key]->get();

        if ($obj === null) {
            // 对象已被垃圾回收，从缓存中移除
            unset($this->weakCache[$key]);
        }

        return $obj;
    }
}

内存分析和调试 ​

php
// 内存分析工具
class MemoryProfiler
{
    private array $profiles = [];
    private ?string $currentProfile = null;

    public function startProfile(string $name): void
    {
        $this->currentProfile = $name;
        $this->profiles[$name] = [
            'start_time' => microtime(true),
            'start_memory' => memory_get_usage(true),
            'start_peak' => memory_get_peak_usage(true),
            'allocations' => []
        ];
    }

    public function recordAllocation(string $description, int $size): void
    {
        if ($this->currentProfile) {
            $this->profiles[$this->currentProfile]['allocations'][] = [
                'description' => $description,
                'size' => $size,
                'timestamp' => microtime(true)
            ];
        }
    }

    public function endProfile(): ?array
    {
        if (!$this->currentProfile) {
            return null;
        }

        $profile = &$this->profiles[$this->currentProfile];
        $profile['end_time'] = microtime(true);
        $profile['end_memory'] = memory_get_usage(true);
        $profile['end_peak'] = memory_get_peak_usage(true);

        $profile['duration'] = $profile['end_time'] - $profile['start_time'];
        $profile['memory_used'] = $profile['end_memory'] - $profile['start_memory'];
        $profile['peak_increase'] = $profile['end_peak'] - $profile['start_peak'];

        $this->currentProfile = null;

        return $profile;
    }

    public function getProfile(string $name): ?array
    {
        return $this->profiles[$name] ?? null;
    }

    public function getAllProfiles(): array
    {
        return $this->profiles;
    }

    public function generateReport(): string
    {
        $report = "内存分析报告\n";
        $report .= str_repeat("=", 50) . "\n\n";

        foreach ($this->profiles as $name => $profile) {
            $report .= "分析: $name\n";
            $report .= "持续时间: " . round($profile['duration'], 4) . "s\n";
            $report .= "内存使用: " . $this->formatBytes($profile['memory_used']) . "\n";
            $report .= "峰值增长: " . $this->formatBytes($profile['peak_increase']) . "\n";
            $report .= "分配次数: " . count($profile['allocations']) . "\n";

            if (!empty($profile['allocations'])) {
                $report .= "主要分配:\n";
                $sorted = $profile['allocations'];
                usort($sorted, fn($a, $b) => $b['size'] <=> $a['size']);

                foreach (array_slice($sorted, 0, 5) as $allocation) {
                    $report .= "  - {$allocation['description']}: " .
                              $this->formatBytes($allocation['size']) . "\n";
                }
            }

            $report .= "\n";
        }

        return $report;
    }

    private function formatBytes(int $bytes): string
    {
        $units = ['B', 'KB', 'MB', 'GB'];
        for ($i = 0; $bytes > 1024 && $i < 3; $i++) {
            $bytes /= 1024;
        }
        return round($bytes, 2) . ' ' . $units[$i];
    }
}

// 使用示例
function demonstrateMemoryProfiling(): void
{
    $profiler = new MemoryProfiler();

    $profiler->startProfile('大数组处理');

    $largeArray = range(1, 100000);
    $profiler->recordAllocation('大数组创建', memory_get_usage(true));

    $processedArray = array_map(fn($x) => $x * 2, $largeArray);
    $profiler->recordAllocation('数组处理', memory_get_usage(true));

    $result = $profiler->endProfile();

    echo $profiler->generateReport();
}

生产环境内存监控 ​

php
// 生产环境内存监控
class ProductionMemoryMonitor
{
    private int $memoryThreshold;
    private int $peakThreshold;
    private string $logFile;

    public function __construct(
        int $memoryThreshold = 128 * 1024 * 1024, // 128MB
        int $peakThreshold = 256 * 1024 * 1024,   // 256MB
        string $logFile = '/var/log/php-memory.log'
    ) {
        $this->memoryThreshold = $memoryThreshold;
        $this->peakThreshold = $peakThreshold;
        $this->logFile = $logFile;
    }

    public function monitor(): void
    {
        $currentMemory = memory_get_usage(true);
        $peakMemory = memory_get_peak_usage(true);

        if ($currentMemory > $this->memoryThreshold) {
            $this->logMemoryWarning('当前内存使用过高', $currentMemory);
        }

        if ($peakMemory > $this->peakThreshold) {
            $this->logMemoryWarning('峰值内存使用过高', $peakMemory);
        }

        // 检查内存泄漏
        $this->checkForMemoryLeaks();
    }

    private function logMemoryWarning(string $message, int $memory): void
    {
        $logEntry = date('Y-m-d H:i:s') . " [警告] $message: " .
                   $this->formatBytes($memory) . "\n";

        file_put_contents($this->logFile, $logEntry, FILE_APPEND | LOCK_EX);
    }

    private function checkForMemoryLeaks(): void
    {
        static $lastCheck = null;
        static $lastMemory = 0;

        $now = time();
        $currentMemory = memory_get_usage(true);

        if ($lastCheck && ($now - $lastCheck) >= 60) { // 每分钟检查一次
            $memoryIncrease = $currentMemory - $lastMemory;
            $increaseRate = $memoryIncrease / 60; // 每秒

            if ($increaseRate > 1024 * 1024) { // 每秒1MB
                $this->logMemoryWarning(
                    '检测到潜在内存泄漏',
                    $memoryIncrease
                );
            }
        }

        $lastCheck = $now;
        $lastMemory = $currentMemory;
    }

    public function getMemoryInfo(): array
    {
        return [
            'current' => memory_get_usage(true),
            'current_formatted' => $this->formatBytes(memory_get_usage(true)),
            'peak' => memory_get_peak_usage(true),
            'peak_formatted' => $this->formatBytes(memory_get_peak_usage(true)),
            'limit' => ini_get('memory_limit'),
            'gc_enabled' => gc_enabled(),
            'gc_status' => gc_status()
        ];
    }

    private function formatBytes(int $bytes): string
    {
        $units = ['B', 'KB', 'MB', 'GB'];
        for ($i = 0; $bytes > 1024 && $i < 3; $i++) {
            $bytes /= 1024;
        }
        return round($bytes, 2) . ' ' . $units[$i];
    }
}

最佳实践总结 ​

  1. 理解引用计数 - 知道变量何时被复制与引用
  2. 使用生成器 - 对大数据集避免将所有内容加载到内存中
  3. 实现适当的清理 - 完成后取消设置大变量
  4. 避免循环引用 - 或确保它们被正确打破
  5. 监控内存使用 - 特别是在生产环境中
  6. 使用弱引用 - 用于缓存实现（PHP 8+）
  7. 优化字符串操作 - 使用数组连接而不是串联
  8. 实现对象池 - 用于频繁创建的昂贵对象
  9. 定期分析 - 使用 Xdebug 和自定义分析器等工具
  10. 设置适当的内存限制 - 基于应用程序的需求

总结 ​

PHP 内存管理这块，说复杂也复杂，说简单也简单。关键是要理解底层原理，知道什么时候该注意，什么时候不用管。

虽然 PHP 帮我们自动管理内存，但不代表我们可以完全不管。特别是做大项目的时候，内存问题往往是性能瓶颈的根源。

几个要点记住：

  • 大数据处理用生成器，别一次性加载到内存
  • 注意循环引用，该断的时候要断
  • 生产环境记得监控内存使用情况
  • 代码写完了测试一下内存占用，心里有个数

最后说一句，过早优化确实是万恶之源，但基本的内存意识还是要有的。毕竟写出来的代码要能跑得稳、跑得快，这是咱们程序员的基本素养。

JaguarJack
后端开发工程师，前端入门选手，略知相关服务器知识，偏爱❤️ Laravel & Vue
本作品采用《CC 协议》，转载必须注明作者和本文链接