При обычном запросе PHP-FPM утечек памяти практически не бывает: PHP освобождает всё по завершении запроса. Реальные утечки возникают в процессах, которые продолжают работать: воркерах очередей, демонах, долгих скриптах импорта и серверах приложений вроде Laravel Octane. Симптом всегда один и тот же. Память немного растет с каждым заданием или запросом, а затем процесс аварийно завершается с ошибкой Allowed memory size exhausted или операционная система убивает его через несколько часов после выполнения вызвавшего это кода. В этой статье показано, как подтвердить наличие утечки, какие четыре причины стоит проверить в первую очередь (каждая воспроизведена и измерена), как найти виновные объекты и как локализовать утечку, которую не получается исправить немедленно.
Если ваша проблема заключается в том, что один запрос потребляет слишком много памяти за раз, это не утечка. Обратите внимание на статью «Allowed memory size exhausted» в PHP.
Как я проводил тестирование
CLI PHP 8.3.6 и код базы данных и событий Laravel 13.35 (реальные классы, запущенные вне полноценного приложения) на SQLite. Все показатели памяти получены из memory_get_usage() , если не указано иное. Каждый результат представляет собой один запуск; значение имеют паттерны роста, а не точное количество мегабайт.
Шаг 1. Убедитесь, что это утечка, а не просто тяжелая задача
Утечка — это память, которая продолжает расти по мере повторения одной и той же работы. Обработайте одну и ту же единицу работы много раз и периодически выводите информацию о памяти. Если график выходит на плато, утечки нет. Если память растет по прямой линии — она есть.
<?php
function report(string $label): void
{
printf("%s: %.1f MB (peak %.1f MB)\n",
$label, memory_get_usage() / 1048576, memory_get_peak_usage() / 1048576);
}
for ($round = 1; $round <= 5; $round++) {
for ($i = 0; $i < 10000; $i++) {
handleOneJob(); // your code here
}
gc_collect_cycles(); // so cycles don't hide the real result
report("after round $round");
}
Вызов gc_collect_cycles() имеет значение. Он освобождает недостижимые циклические ссылки, поэтому весь оставшийся рост — это память, которую ваш код продолжает удерживать. Три функции PHP, которые полезно знать во время измерений:
- memory_get_usage() — это объем памяти, выделенный вашим скриптом. memory_get_usage(true) — это то, что PHP зарезервировал у системы более крупными блоками. В моем тесте с одной строкой на 5 МБ они показали 5,4 МБ и 7,0 МБ. Воркер очереди Laravel проверяет значение true .
- memory_get_peak_usage() — это пиковое значение потребления памяти. Начиная с PHP 8.2, memory_reset_peak_usage() сбрасывает его, чтобы можно было измерять каждый этап по отдельности. Мой тест: освобожденная строка на 50 МБ оставила пик на уровне 50,4 МБ, а после сброса пик составил 0,4 МБ.
Причина 1: статический массив, синглтон или глобальная переменная, которые только растут
Классическая утечка. Что-то сохраняет данные «на потом», и ничто никогда их не удаляет. Я симулировал 50 000 единиц работы, каждая из которых сохраняла полезную нагрузку размером 1 КБ:
class Cache { public static array $items = []; }
Cache::$items[$id] = $payload; // grows forever
unbounded static cache: after 10000: 12.9 MB ... after 50000: 62.5 MB
bounded cache (max 1000): after 10000: 1.7 MB ... after 50000: 1.7 MB
Способы исправления в порядке предпочтения: вообще не кэшировать данные, если их дешево перезагрузить; ограничить кэш (задать максимальный размер с вытеснением самой старой записи); или привязать время жизни кэшированных данных к объекту, которому они принадлежат, с помощью WeakMap , что приводит к удалению записи при освобождении объекта-ключа:
$map = new WeakMap(); $user = new stdClass(); $map[$user] = ['expensive' => 'data']; echo count($map); // 1 unset($user); echo count($map); // 0
В Laravel та же ловушка скрывается в синглтонах, зарегистрированных в контейнере, статических свойствах в сервисах и трейтах со статическим состоянием. Они безвредны при работе с PHP-FPM и опасны при использовании Octane или queue:work . В документации Octane (на странице документации версии 9.x; проверьте актуальную) приводится именно этот пример: добавление данных в статический массив при каждом запросе является утечкой памяти, поскольку Octane держит приложение в памяти между запросами.
Причина 2: циклические ссылки и почему сборщик мусора PHP не всегда вас спасает
PHP освобождает большинство значений в тот момент, когда на них больше ничего не ссылается. Объекты, которые ссылаются друг на друга, никогда не достигают нулевого счетчика ссылок, поэтому в PHP есть отдельный сборщик циклических ссылок. Он работает, и именно поэтому циклы являются причиной проблем реже, чем люди ожидают. Я создал 100 000 пар объектов, ссылающихся друг на друга, и удалил их:
GC enabled: after 100000: 2.5 MB gc runs=19 collected=285000
GC disabled: after 100000: 42.1 MB gc runs=0 roots=200000
manual gc_collect_cycles() freed 300000; memory back to 2.4 MB
Таким образом, при включенном сборщике эти циклы не создают долгосрочных затрат. Подводный камень заключается в том, когда именно он запускается. Сборщик срабатывает, когда количество возможных корней циклов достигает порогового значения ( gc_status()['threshold'] было равным 10001 в моем тесте), а не тогда, когда память заканчивается. Поэтому крупные объекты в циклах могут исчерпать память до того, как сборщик вообще проснется. Я создал объекты, которые ссылались сами на себя и каждый содержал по 200 КБ, при лимите в 128 МБ:
GC enabled, large self-referencing objects: iteration 500: 96.2 MB PHP Fatal error: Allowed memory size of 134217728 bytes exhausted same loop with gc_collect_cycles() every 100 iterations: iteration 3000: 0.4 MB finished
В цикле, который создает большие циклические структуры (разобранные документы, большие графы объектов), вызывайте gc_collect_cycles() каждые несколько сотен итераций или разрывайте цикл. Не вызывайте его на каждой итерации и не отключайте сборщик: у него есть своя цена, а его отключение просто сделало первый тест выше в 17 раз хуже.
Незаметный цикл: замыкание, захватывающее $this
Стрелочная функция или замыкание, созданные внутри метода, автоматически захватывают $this . Если вы сохраните это замыкание в том же объекте, вы создадите цикл. Я проверил с помощью WeakReference , когда объект действительно освобождается при отключенном сборщике:
class Report {
public $cb; public $data;
public function __construct(bool $static) {
$this->data = str_repeat('x', 100000);
$this->cb = $static ? static fn () => 1 : fn () => $this->data;
}
}
capturing closure: freed right after unset? NO (waits for GC)
static closure: freed right after unset? yes
Если колбэк не использует $this , объявите его как static . Он не сможет создать цикл, и объект будет освобожден немедленно.
Причина 3: слушатели и колбэки, регистрируемые снова и снова
Регистрация слушателя событий внутри кода, который выполняется для каждого задания или запроса, каждый раз добавляет нового слушателя. Каждый из них удерживает замыкание и все, что это замыкание захватило. Я зарегистрировал одного слушателя на «задание» в диспетчере событий Laravel:
registered once: after 20000 jobs: 0.9 MB listeners=1 registered per job: after 20000 jobs: 16.2 MB listeners=20000
Память росла по прямой линии, и каждое отправленное событие также начинает выполняться медленнее, потому что теперь оно вызывает 20 000 слушателей. В Laravel регистрируйте слушателей один раз — в методе boot() сервис-провайдера или в сопоставлении событий и слушателей, но никогда внутри метода handle() задания, контроллера или цикла. То же самое относится к Model::observe() , макросам и любым вызовам on() / listen() для долгоживущих объектов.
Причина 4: журнал запросов в долго работающем процессе
Laravel может записывать каждый запрос. По умолчанию эта функция отключена, поэтому она проявляется только тогда, когда кто-то включает ее для отладки и забывает выключить, либо когда это делает какой-то пакет. В воркере или долго выполняющейся команде журнал растет без ограничений. Я прогнал через соединение с базой данных 20 000 тривиальных запросов:
query log off: after 20000 queries: 4.8 MB log entries=0
query log on: after 20000 queries: 18.2 MB log entries=20000
after DB::connection()->flushQueryLog(): 4.8 MB
// if you need the log inside a long loop, clear it as you go
DB::connection()->enableQueryLog();
foreach ($ids->chunk(500) as $chunk) {
// ... work ...
DB::connection()->flushQueryLog();
}
DB::connection()->disableQueryLog();
Поищите в своем коде и отладочных пакетах enableQueryLog . Схожий случай формально не является утечкой, но выглядит именно так: загрузка целых таблиц в память. Используйте chunkById() , lazyById() или cursor() . Я замерил 54 МБ для get() на 20 000 строках против 8–12 МБ для вариантов потоковой передачи в статье о производительности Laravel 13.
Узнайте, какие объекты удерживаются в памяти: php-meminfo
Когда стандартные подозреваемые не помогают объяснить проблему, нужно посмотреть, что именно находится в памяти. Расширение php-meminfo выгружает каждый живой элемент в процессе в формате JSON. Я собрал его из исходного кода для PHP 8.3.6 ( phpize , ./configure --enable-meminfo , make ) и выполнил дамп после создания 1500 объектов, которые удерживались, и 300, которые не удерживались:
// php -d extension=/path/to/meminfo.so script.php
$fh = fopen('/tmp/dump.json', 'w');
meminfo_dump($fh);
fclose($fh);
Подсчет объектов по классам в этом дамп-файле:
[('Order', 1500), ('Tmp', 1)]
Класс, у которого экземпляров намного больше, чем должно быть, и является вашей утечкой. В репозитории проекта есть анализатор для этого; в его README описаны команды bin/analyzer summary , top-children , query -f "class=Order" и ref-path <item-id> , где ref-path показывает, что все еще ссылается на заданный объект. Я не смог запустить анализатор (ему требуются пакеты Composer, которые я не смог скачать), поэтому вместо этого подсчитал классы с помощью короткого скрипта.
Два предупреждения. В README указаны PHP 7.x и 8.0, а последний коммит, который я видел, был датирован мартом 2022 года, поэтому относитесь к этому как к неподдерживаемому инструменту: в моем тесте он сработал для дампа на 8.3.6, но сначала протестируйте его на стейджинг-копии. Дампы реального воркера получаются большими, поэтому никогда не запускайте его при наличии продакшн-трафика.
Локализация утечки, которую не удается исправить сегодня
Перезапуск процесса — вполне рабочий временный костыль, если относиться к нему именно как к временному решению.
Воркеры очередей Laravel. Из исходного кода Laravel 13:
php artisan queue:work --memory=256 --max-jobs=1000 --max-time=3600
- --memory по умолчанию равен 128 (МБ). В исходном коде 13.x он также принимает процент от лимита памяти PHP memory_limit , например 50% . Воркер сравнивает memory_get_usage(true) в мегабайтах с лимитом, и при его достижении завершает работу с кодом выхода 12.
- --max-jobs и --max-time останавливают воркер после обработки указанного количества заданий или истечения секунд.
- Остановленному воркеру требуется что-то, что запустит его снова, например Supervisor или systemd. Смотрите статью Задания очереди Laravel не обрабатываются или зависли. Установите --memory ниже лимита памяти PHP memory_limit , чтобы воркер корректно завершал работу между заданиями, а не умирал посередине одного из них.
PHP-FPM. В конфигурации пула pm.max_requests — это количество запросов, которые дочерний процесс обрабатывает перед перезапуском. В руководстве по PHP говорится, что это может быть полезно для обхода утечек памяти в сторонних библиотеках, а значение по умолчанию равно 0, что означает отсутствие перезапусков:
pm.max_requests = 500
Octane. В документации к версии 9.x указано, что по умолчанию Octane перезапускает воркер после 500 запросов, это значение можно настраивать с помощью php artisan octane:start --max-requests=250 . Я не запускал Octane для этой статьи.
Частые ошибки
- Доверие одному измерению. Одно считывание ничего не доказывает. Повторите работу и проследите за трендом.
- Измерения без предварительного сбора циклических ссылок. Вы можете гоняться за мусором, который PHP собирался освободить.
- Вызов unset() в ожидании уменьшения размера процесса. PHP переиспользует освобожденную память внутри себя. Судите по memory_get_usage() на разных итерациях, а не по размеру процесса в top .
- Отключение сборщика мусора ради скорости. Мой тест циклов показывает, во что это обходится.
- Увеличение memory_limit вместо поиска источника роста. Это лишь откладывает падение.
- Оставленные включенными инструменты отладки. Логирование запросов, запись событий и подобные инструменты удерживают все, что они записывают.
- Отношение к перезапускам как к исправлению. --max-jobs и pm.max_requests скрывают утечку, а утечка, которая растет достаточно быстро, все равно убьет процесс между перезапусками.
Связанные статьи и инструменты Dev Talk
- PHP "Allowed memory size exhausted"
- Laravel queue jobs not processing or stuck
- Docker build taking too long? 10 ways to speed it up
Инструменты: memory_get_usage() , memory_reset_peak_usage() и gc_status() (встроены в язык и использовались выше), расширение php-meminfo и профилировщик с поддержкой анализа памяти, такой как Blackfire. Я не использовал профилировщик для этой статьи.
Часто задаваемые вопросы
Есть ли в PHP утечки памяти?
Сам по себе PHP освобождает всю память запроса по его завершении, поэтому обычные приложения на PHP-FPM редко страдают от утечек в долгосрочной перспективе. Долго работающие процессы могут накапливать память через ваш код (статические данные, слушатели, логи), через циклы ссылок, которые еще не были собраны, и иногда через баги в расширениях или библиотеках.
Стоит ли вызывать gc_collect_cycles() в своем коде?
Только в длинных циклах, которые создают большие циклические структуры, и каждые несколько сотен итераций, а не на каждой итерации. Мой тест показал, что это может стать разницей между успешным завершением и фатальной ошибкой. Для небольших объектов автоматического сборщика вполне достаточно.
Почему память процесса в top не уменьшается после вызова unset()?
PHP сохраняет освобожденную память для ее повторного использования. memory_get_usage(true) сообщает объем памяти, зарезервированный PHP, который больше того, что используют ваши данные (7,0 против 5,4 МБ в моем тесте). Оценивайте рост по тренду на разных итерациях.
Является ли Xdebug правильным инструментом для поиска утечек?
Я не тестировал его для этого. Я использовал встроенные функции работы с памятью для поиска тренда и php-meminfo, чтобы увидеть, что именно удерживается, поэтому сначала используйте их.
Является ли лимит памяти для воркеров очередей реальным решением?
Нет. Он защищает вас от сбоя путем чистого перезапуска. Используйте это как страховочную сетку, пока ищете причину.
Оригинал опубликован на DEV Talk.
Комментарии (0)
Пока нет комментариев — будьте первым.