Cache stampede — это ситуация, когда срок действия популярного кешированного объекта заканчивается почти одновременно для большого количества запросов. Каждый PHP-процесс видит пустой кеш и пытается самостоятельно выполнить тот же тяжелый SQL-запрос, обратиться к внешнему API или сформировать сложный отчет.
В результате кеш, который должен был снижать нагрузку, становится причиной пиков на MySQL, PHP workers или API. В WordPress проблему обычно решают с помощью краткосрочного lock в persistent Object Cache: только один запрос перестраивает данные, а остальные используют fallback, старое значение или ждут ограниченное время.
Что такое cache stampede и как он возникает
Представим, что популярный отчет хранится в Object Cache в течение 5 минут. После завершения TTL десятки или сотни одновременных запросов получают cache miss. Если код не предусматривает защиту, каждый из них запускает my_build_report() и выполняет одну и ту же дорогостоящую операцию.
Проблема особенно заметна на страницах с высоким трафиком, в REST API, во время массовых запусков cron и после очистки Redis или Memcached. Даже если один SQL-запрос не кажется критичным, его параллельный запуск множеством PHP-процессов может исчерпать подключения к базе данных.
- одновременное завершение TTL для популярного ключа;
- повторное выполнение тяжелых SQL-запросов;
- рост количества PHP workers и времени ответа;
- пиковая нагрузка на MySQL или внешний API;
- цепная реакция: медленная база данных замедляет работу всего сайта.
Когда lock в Object Cache действительно работает
Для защиты нужен shared persistent object cache — обычно Redis или Memcached, подключенный к WordPress через соответствующий drop-in. Обычный объектный кеш WordPress без persistent backend часто существует только в течение одного PHP-запроса. В таком случае разные запросы не видят общий lock, и защита от cache stampede не работает.
Ключевая операция — wp_cache_add(). Она добавляет ключ только в том случае, если такого ключа еще нет. При корректной работе backend это позволяет одному запросу получить lock, а остальным понять, что перестроение уже выполняется.
Перед внедрением убедитесь, что production-среда действительно использует Redis или Memcached, а не только установленный плагин без активного drop-in. Также протестируйте поведение после перезапуска PHP, очистки кеша и потери соединения с backend.
- lock должен быть краткосрочным и иметь TTL;
- ключ блокировки должен быть отдельным для каждого дорогостоящего объекта;
- TTL lock должен покрывать обычную продолжительность операции, но не сохраняться бесконечно;
- нельзя использовать один глобальный lock для всего сайта.
Базовая реализация защиты в WordPress
Ниже приведен упрощенный шаблон для отчета или другой дорогостоящей операции. Запрос, получивший lock, формирует данные и записывает их в кеш. Остальные запросы не запускают ту же операцию повторно: они могут использовать резервное значение или повторить чтение после короткой паузы.
Группа custom помогает логически отделить ключи этого механизма. Имена ключей стоит делать специфичными для объекта, сайта, языка или набора параметров, если результат зависит от этих значений.
$key = 'expensive_report:v1';
$group = 'custom';
$lock = 'lock:' . $key;
$found = false;
$data = wp_cache_get($key, $group, false, $found);
if (!$found) {
// TTL lock должен быть больше обычного времени формирования отчета.
if (wp_cache_add($lock, 1, $group, 30)) {
try {
$data = my_build_report(); // SQL-запрос или обращение к API
if (false !== $data && null !== $data) {
wp_cache_set($key, $data, $group, 300);
}
} finally {
wp_cache_delete($lock, $group);
}
} else {
// Другой запрос уже перестраивает данные.
$data = my_get_stale_report_or_fallback();
}
}
return $data;
Почему нельзя просто выполнить операцию после cache miss
Проверка кеша и запуск тяжелой функции без lock создают race condition: несколько процессов одновременно видят отсутствие ключа. Именно wp_cache_add(), а не последовательность wp_cache_get() плюс wp_cache_set(), должна использоваться для захвата блокировки.
Также обрабатывайте ошибки формирования данных. Если API вернул ошибку или SQL-запрос завершился неудачно, не записывайте пустой или некорректный результат на длительный TTL. Иначе временный сбой превратится в закешированный результат.
- используйте отдельный lock для каждого набора параметров;
- всегда задавайте TTL для lock;
- освобождайте lock в блоке finally, если это совместимо с вашей версией PHP;
- не считайте значение false надежным признаком cache miss без проверки параметра found.
Что возвращать запросам, которые не получили lock
Оптимальный вариант зависит от типа данных и требований к их актуальности. Для каталога, статистики или рекомендаций часто достаточно вернуть предыдущую версию результата. Для критически важных данных можно выполнить повторное чтение после короткой задержки, но такое ожидание нужно ограничивать, чтобы не создать новую очередь PHP-процессов.
Практичный подход — хранить актуальный результат и его stale-копию под разными ключами. Если основной ключ пуст, а lock уже занят, код возвращает stale-значение. Пользователь получает быстрый ответ, а один фоновый или обычный запрос завершает обновление.
Если fallback отсутствует, верните безопасный пустой результат, HTTP-ошибку или сообщение о временной недоступности — в зависимости от контекста. Хуже контролируемого fallback только запуск одного и того же тяжелого запроса в каждом процессе.
- stale-while-revalidate для данных, которые могут быть немного устаревшими;
- короткое повторное чтение кеша для небольших операций;
- резервный результат из базы данных или локального конфигурационного значения;
- контролируемый error response для критически важных API-операций.
TTL, jitter и защита от повторной волны запросов
Одинаковый TTL для большого количества ключей может создать несколько волн нагрузки. Это происходит, когда объекты были записаны одновременно после очистки кеша или массового импорта.
Для независимых объектов можно добавлять небольшой случайный интервал к TTL. Например, базовый срок 300 секунд можно изменять в пределах нескольких десятков секунд. Это распределяет завершение срока действия во времени, но не заменяет lock: даже при использовании jitter один популярный ключ может одновременно запрашиваться множеством процессов.
TTL lock нужно подбирать с учетом реальной продолжительности операции. Если отчет обычно формируется за 3 секунды, 30 секунд может быть достаточно. Если иногда формирование занимает больше времени, чем TTL, lock завершится преждевременно, и второй процесс начнет дублировать работу.
- не используйте слишком короткий TTL lock;
- не задавайте чрезмерно длинный TTL, который замедляет восстановление после падения процесса;
- добавляйте jitter к TTL данных, если множество ключей создается одновременно;
- для очень длительных задач рассмотрите очередь или фоновую генерацию вместо ожидания в HTTP-запросе.
$base_ttl = 300;
$jitter = wp_rand(0, 30);
$ttl = $base_ttl + $jitter;
wp_cache_set($key, $data, 'custom', $ttl);
Важные ограничения и типичные ошибки
wp_cache_add() имеет смысл как атомарный lock только в том случае, если конкретный persistent backend и drop-in корректно поддерживают эту операцию. Не полагайтесь на поведение локальной тестовой среды, если в production используется другой Redis или Memcached.
Простое удаление lock после завершения операции также имеет нюанс: если формирование данных длилось дольше TTL, lock мог уже перейти другому запросу. После завершения первый процесс может удалить lock нового владельца. Для самых высоких требований нужен backend-специфичный механизм проверки владельца и атомарного удаления, например операция на уровне Redis. В типичном коде WordPress минимизируйте этот риск за счет корректного TTL и не допускайте слишком длительных синхронных задач.
Не используйте один ключ lock для всех отчетов или всего сайта. Медленный отчет в таком случае заблокирует независимые операции. В то же время чрезмерно детализированные ключи могут создать множество параллельных перестроений, поэтому область блокировки нужно определять с учетом реальной стоимости операции.
- не путайте Object Cache с page cache: lock должен быть доступен всем PHP-процессам;
- не записывайте результат в кеш после ошибки или неполного ответа API;
- не выполняйте бесконечный polling в пользовательском запросе;
- не очищайте весь Redis из-за одного проблемного ключа, если можно удалить только нужную группу или версию ключа.
Как проверить, что защита работает
Проводите проверку в условиях, близких к production. Сначала убедитесь, что повторное чтение одного ключа действительно возвращает данные из Redis или Memcached. Затем очистите конкретный ключ и создайте параллельные запросы к endpoint или странице, которая запускает дорогостоящую операцию.
В логах временно фиксируйте захват lock, cache hit, cache miss, продолжительность формирования, fallback и ошибки backend. Во время теста ожидается один запуск my_build_report(), а не отдельный запуск для каждого параллельного запроса.
Отдельно проверьте сценарии медленного SQL, ошибки API, перезапуска Redis, завершения PHP-процесса и превышения TTL lock. Мониторинг должен показывать не только количество cache hit, но и время ответа, количество подключений к MySQL и частоту перестроения популярных ключей.
- проверьте активность persistent object cache в production;
- сравните количество cache miss с количеством фактических перестроений;
- проверьте поведение при одновременных запросах после очистки ключа;
- отслеживайте lock timeout и случаи срабатывания fallback;
- убедитесь, что сбой кеша не запускает неконтролируемый поток SQL-запросов.
Частые вопросы
Защитит ли wp_cache_add() от cache stampede без Redis или Memcached?
Нет, не гарантированно. Для разных PHP-запросов требуется общее persistent-хранилище. Если Object Cache работает только в пределах одного запроса, процессы не увидят общий lock.
Каким должен быть TTL для lock?
Он должен быть больше обычного времени выполнения дорогостоящей операции, но ограниченным, чтобы lock автоматически исчезал после аварии. Ориентируйтесь на измеренную продолжительность формирования и добавьте запас.
Можно ли заставить все остальные запросы ждать завершения перестроения?
Можно выполнить несколько коротких повторных чтений с паузой, но это нужно ограничить. Для большинства страниц безопаснее вернуть stale-значение или fallback, чем создавать очередь PHP-процессов.
Достаточно ли добавить случайный TTL вместо lock?
Нет. Jitter снижает вероятность одновременного завершения TTL для разных ключей, но не решает проблему, когда один популярный ключ одновременно запрашивают десятки процессов.
Что делать, если операция выполняется дольше, чем TTL lock?
Увеличьте TTL после измерений, оптимизируйте SQL- или API-запрос и рассмотрите фоновую генерацию через очередь. Также учитывайте риск повторного захвата lock после его преждевременного завершения.
Вывод
Защита от cache stampede в WordPress состоит из трех частей: shared persistent Object Cache, атомарного захвата lock и корректного поведения запросов, которые не получили lock. Один процесс перестраивает дорогостоящие данные, а остальные используют stale-результат, fallback или короткое повторное чтение.
Начните с проверки Redis или Memcached, разделите lock-ключи для конкретных объектов, задайте реалистичный TTL и добавьте мониторинг cache miss и фактических перестроений. Это поможет снизить пики нагрузки на MySQL, не создавая новое узкое место в PHP.