♻️ Память, счётчик ссылок и GC
В CPython память освобождают два механизма: счётчик ссылок удаляет объект в момент, когда на него перестали ссылаться, а сборщик циклов подбирает то, что счётчик не видит. От этого зависит, когда закроется файл, почему сервис растёт в памяти после недели аптайма и почему del большого списка не уменьшает RSS в мониторинге. На собеседовании тему спрашивают и как теорию, и как разбор утечки на проде
🧠 Как это устроено
Счётчик ссылок
У каждого объекта в CPython есть поле ob_refcnt. Присвоили объект переменной, положили в список, передали в функцию — счётчик растёт. Имя переприсвоили, список очистили, функция вернулась — уменьшается. Когда счётчик доходит до нуля, объект освобождается сразу, в той же строке, без отдельного прохода сборщика
import sys
a = []
print(sys.getrefcount(a)) # 2
b = a
print(sys.getrefcount(a)) # 3Ссылка одна, а функция показывает 2. Пока идёт вызов, сам аргумент getrefcount держит ещё одну временную ссылку, поэтому значение на единицу больше ожидаемого. Документация советует не полагаться на точное число, кроме 0 и 1: у части объектов счётчик вообще не отражает реальность (о них ниже)
del x не удаляет объект. Он убирает имя x и уменьшает счётчик на единицу. Если других ссылок нет, объект освободится и вызовется __del__, если есть ещё — ничего не произойдёт
Когда вызывается __del__
Мгновенное освобождение — деталь CPython, а не гарантия языка, и справочник просит не рассчитывать на него. Ограничения у __del__ такие:
- для объектов, которые ещё живы при выходе интерпретатора, вызов не гарантирован
- исключения внутри
__del__не выбрасываются наружу, а печатаются предупреждением в stderr - он может сработать в любом потоке и посреди любого кода, поэтому взять в нём блокировку — путь к дедлоку
- при остановке интерпретатора глобальные переменные и модули к этому моменту уже могут быть
None
Для освобождения ресурсов есть with и явный close(). Если нужен колбэк на смерть объекта, бери weakref.finalize: он вызывается не больше одного раза и по умолчанию срабатывает и при выходе
Циклы и поколенческий сборщик
Счётчик ссылок бессилен против циклов. Объект a ссылается на b, b на a, снаружи на них никто не смотрит, а счётчики у обоих равны единице. Для этого есть сборщик циклов, модуль gc
import gc
class Node:
def __init__(self, name):
self.name = name
self.other = None
def __del__(self):
print("удалён", self.name)
n = Node("одиночка")
n = None # счётчик упал до нуля
print("после n = None")
a, b = Node("a"), Node("b")
a.other, b.other = b, a # цикл
del a, b
print("после del, цикл жив")
print("собрано:", gc.collect())Вывод на Python 3.14.9:
удалён одиночка
после n = None
после del, цикл жив
удалён a
удалён b
собрано: 2Одиночка ушёл сразу, пара из цикла дождалась сборщика. Объекты с __del__ в цикле собираются нормально с Python 3.4 (PEP 442), раньше они оседали в gc.garbage
Сборщик смотрит только на контейнеры: списки, словари, кортежи, экземпляры классов, то есть всё, что может ссылаться на другие объекты. Числа и строки цикл образовать не могут, их он не отслеживает, это видно по gc.is_tracked(1) и gc.is_tracked("s"), оба дают False
Мусор сборщик ищет так. Для каждого отслеживаемого контейнера сборщик заводит копию счётчика и вычитает из неё все ссылки, которые идут от других контейнеров из того же набора. У кого после вычитания осталось больше нуля, на того ссылаются снаружи: стек, глобальные переменные, C-код. Такие объекты и всё, до чего от них можно дойти, живые. Остальное — мусор, даже если счётчики у него не нулевые
Проверять всю кучу на каждом шаге дорого, поэтому объекты разбиты на три поколения. Новые попадают в поколение 0, пережившие сборку переезжают в 1, затем в 2. Большинство объектов умирает молодыми, поэтому молодое поколение проверяют чаще
| Порог | Что значит | По умолчанию в 3.14.9 |
|---|---|---|
threshold0 | сборка поколения 0 начинается, когда выделений контейнеров минус освобождений стало больше порога | 2000 |
threshold1 | поколение 1 проверяется вместе с 0 после стольких сборок поколения 0 | 10 |
threshold2 | то же для поколения 2 относительно сборок поколения 1 | 10 |
Значения возвращает gc.get_threshold(), текущие счётчики — gc.get_count(). Без аргументов gc.collect() собирает все поколения и возвращает число найденных недостижимых объектов, gc.collect(0) — только молодое
История с инкрементальным сборщиком в 3.14
В Python 3.14.0–3.14.4 сборщик был инкрементальным: два поколения вместо трёх, за раз собиралось молодое поколение и порция старого, чтобы паузы на больших кучах стали короче. gc.collect(1) в этих версиях делал «порцию» сборки, а threshold2 игнорировался
В 3.14.5 изменение откатили к поколенческому сборщику из 3.13. Причина по What's New — несколько сообщений о заметном росте потребления памяти в продакшене. Документация модуля gc теперь содержит пометки «Changed in version 3.14.5»: threshold2 снова работает, gc.collect(1) снова собирает среднее поколение. Сервис на 3.14.0–3.14.4 вырос в памяти после переезда с 3.13 — первым делом обнови патч-версию
Отключение и gc.freeze
gc.disable() выключает только автоматический сборщик циклов. Счётчик ссылок работает как раньше, всё без циклов освобождается сразу. Отключают его в двух случаях: короткий скрипт или пакетная задача, где циклы точно не накапливаются, и пре-форк серверы
Gunicorn с --preload или любой сервер, который загружает приложение в мастер-процессе и потом делает fork() без exec(), рассчитывает на copy-on-write: дочерние процессы делят страницы памяти с родителем, пока в них не пишут. Сборщик при обходе пишет в заголовки объектов, и общие страницы копируются в каждый воркер. Документация gc предлагает схему: gc.disable() в начале работы мастера, gc.freeze() прямо перед fork(), gc.enable() в начале работы дочернего процесса. freeze переносит все отслеживаемые объекты в постоянное поколение, и сборщик их больше не трогает
weakref для кэшей
Слабая ссылка указывает на объект, но не увеличивает его счётчик. Объект умрёт, когда исчезнут обычные ссылки, а слабая начнёт возвращать None. На этом построены WeakValueDictionary и WeakKeyDictionary: запись пропадает сама, когда объект больше никому не нужен
import weakref
class Report:
def __init__(self, rid):
self.rid = rid
cache = weakref.WeakValueDictionary()
r = Report(42)
cache[42] = r
print(42 in cache) # True
del r
print(42 in cache) # FalseТакой кэш подходит, когда объект и так где-то живёт, а найти его нужно по ключу, не продлевая ему жизнь: соединения по id, загруженные модели, наблюдатели. Ограничение: на int и tuple слабую ссылку не создать даже через подкласс, на list и dict — только через подкласс
pymalloc и почему RSS не падает
Мелкие объекты, до 512 байт, CPython не просит у ОС по одному. Их раздаёт собственный аллокатор pymalloc: он берёт у системы большие куски, арены, по 1 МиБ на 64-битных платформах (256 КиБ на 32-битных), режет их на пулы и раздаёт блоки фиксированных размеров. Всё больше 512 байт идёт в системный malloc
Отсюда поведение, о котором спрашивают на собеседованиях. Освобождённый объект возвращает блок в пул, а не память в ОС. Арена уходит системе, только когда в ней не осталось ни одного живого объекта. Удалил список из миллиона мелких объектов, а среди них остались жить несколько тысяч, разбросанных по аренам, — арены держатся, и RSS процесса почти не меняется. Память при этом не потеряна: Python переиспользует свободные блоки под новые объекты
Практический вывод: рост RSS сам по себе ещё не утечка. Утечка — когда память растёт под одинаковой нагрузкой без плато
Бессмертные объекты
С Python 3.12 (PEP 683) у части объектов счётчик не меняется вообще: None, True, False, малые целые, встроенные типы. Их счётчик стоит на огромном значении, sys.getrefcount(None) на 3.14.9 вернул 3221225472. Зачем: запись в счётчик портит кэш процессора, когда несколько ядер трогают один None, и ломает copy-on-write после fork(). Проверить объект можно через sys._is_immortal(), он появился в 3.14
🛠️ На практике
Откуда берутся утечки
В Python утечка почти всегда значит «на объект кто-то всё ещё ссылается». Частые источники:
- кэш без лимита: модульный словарь, куда складывают ответы по
request_id, или@lru_cache(maxsize=None) lru_cacheна методе:selfвходит в ключ, кэш держит ссылку на каждый экземпляр, и он живёт, пока запись не вытеснена. Документация в Programming FAQ говорит об этом прямо. Для методов без аргументов бериfunctools.cached_property, он хранит результат в самом экземпляре- глобальный список, куда дописывают «для отладки» или для метрик и никогда не чистят
- замыкание или колбэк, который захватил крупный объект, а сам колбэк зарегистрирован в долгоживущем месте: обработчике событий, сигнале, планировщике
- пойманное исключение, сохранённое в атрибут или список: оно держит traceback, а traceback держит локальные переменные всех кадров
Проверка про lru_cache на 3.14.9:
from functools import lru_cache
import gc, weakref
class Service:
@lru_cache(maxsize=None)
def price(self, sku):
return len(sku)
s = Service()
s.price("abc")
ref = weakref.ref(s)
del s
gc.collect()
print(ref()) # <__main__.Service object at 0x...>, экземпляр живКак искать: tracemalloc
tracemalloc из стандартной библиотеки ставит хуки на аллокаторы Python и запоминает, в какой строке выделен каждый блок. Схема поиска утечки: снять снимок, прогнать нагрузку, снять второй, сравнить
import tracemalloc
_cache = {}
def handle(request_id, payload_size=1000):
_cache[request_id] = "x" * payload_size # кэш без лимита
tracemalloc.start()
before = tracemalloc.take_snapshot()
for i in range(10_000):
handle(i)
after = tracemalloc.take_snapshot()
for stat in after.compare_to(before, "lineno")[:3]:
print(stat)Первые две строки вывода на Python 3.14.9 (путь к файлу укорочен):
leak.py:6: size=10.2 MiB (+10.2 MiB), count=10001 (+10001), average=1070 B
leak.py:11: size=301 KiB (+301 KiB), count=9643 (+9643), average=32 BСтрока 6 выросла на 10 МиБ и 10 тысяч блоков — это строки в кэше. Строка 11 — целые числа i, которые стали ключами. В сервисе снимки берут под нагрузкой с паузой в минуты и ищут строку, которая растёт
По умолчанию хранится один кадр стека, для разбора «кто вызвал» запусти tracemalloc.start(25) и группируй по "traceback". Включить с самого старта можно через PYTHONTRACEMALLOC=1 или -X tracemalloc. Больше кадров — больше расход памяти и CPU, на проде включай на время расследования. tracemalloc видит только память, выделенную через аллокаторы Python: буферы C-расширений вроде numpy он покажет не всегда. Обзор внешних профилировщиков памяти, memray и других, — на странице про профилирование
Кто держит растущий объект, покажет gc.get_referrers(obj), но только при отладке: функция медленная
⚠️ Где ошибаются
Закрывают ресурсы в __del__. На CPython «работает», потому что счётчик срабатывает сразу. Стоит объекту попасть в цикл или дожить до остановки интерпретатора, и соединение останется открытым. Закрывай через with или close()
Считают del удалением объекта. del убирает одно имя. Если объект лежит ещё в кэше или списке, он живёт дальше
Отключают gc «для скорости» в долгоживущем сервисе. Каждый цикл, например исключение с traceback или двусвязный список, останется в памяти навсегда. Отключают в коротких задачах или по схеме с gc.freeze() перед fork()
Принимают рост RSS за утечку. После пика нагрузки процесс держит арены, и график не возвращается вниз. Сравни снимки tracemalloc, прежде чем искать виноватого
Вешают lru_cache(maxsize=None) на метод. Кэш класса держит все экземпляры, которые через него прошли. Нужен лимит, cached_property или кэш на уровне модуля по ключу без self
🎯 Вопросы с собеседований
Как CPython управляет памятью?
Основной механизм — счётчик ссылок: у каждого объекта есть ob_refcnt, и когда он падает до нуля, объект освобождается сразу. Циклы счётчик не ловит, для них есть сборщик циклов из модуля gc. Он отслеживает только контейнеры, делит их на три поколения и чаще проверяет молодое: по умолчанию сборка поколения 0 запускается после 2000 выделений сверх освобождений
Когда объект удаляется? Гарантирован ли вызов __del__?
В CPython объект без циклов удаляется в момент, когда исчезает последняя ссылка, объект в цикле — при ближайшей сборке gc. Но язык этого не обещает: другая реализация, например PyPy, может освобождать позже. __del__ не гарантирован для объектов, живых при выходе интерпретатора, исключения в нём только печатаются в stderr. Поэтому ресурсы закрывают через with, а для колбэка на смерть объекта есть weakref.finalize
Зачем нужен gc, если есть счётчик ссылок? Можно ли его отключить?
Счётчик не освобождает циклы: два объекта ссылаются друг на друга, и счётчики не обнулятся никогда. Сборщик находит такие группы, вычитая внутренние ссылки между контейнерами. gc.disable() выключает только автоматический сборщик циклов, счётчик продолжает работать. Отключают в коротких задачах без циклов и в пре-форк серверах вроде Gunicorn с --preload: там gc.disable() в мастере и gc.freeze() перед fork() сохраняют copy-on-write, потому что сборщик не пишет в общие страницы
Почему процесс не отдаёт память ОС после удаления большого списка?
Мелкие объекты живут в аренах pymalloc по 1 МиБ, и арена возвращается системе, только когда в ней не осталось ни одного живого объекта. Если среди удалённых остались выжившие, разбросанные по аренам, арены держатся. Освобождённые блоки Python переиспользует под новые объекты, так что память не потеряна, она просто не видна ОС как свободная
Что такое weakref и где он пригодится?
Слабая ссылка указывает на объект, но не увеличивает счётчик, поэтому не продлевает объекту жизнь. Когда обычных ссылок не осталось, объект удаляется, а слабая ссылка возвращает None. На ней построены WeakValueDictionary для кэшей объектов, которые живут где-то ещё, и WeakKeyDictionary для метаданных к чужим объектам. Ещё её используют в списках наблюдателей и для ссылки ребёнка на родителя в деревьях
Как найти утечку памяти в сервисе?
Сначала убедиться, что это утечка: память растёт под ровной нагрузкой и не выходит на плато. Потом включить tracemalloc, снять снимок, дать сервису поработать и сравнить второй снимок с первым через compare_to(..., "lineno"): сверху окажется строка, где копятся выделения. Обычно виноват кэш без лимита, глобальный список, lru_cache на методе или колбэк, захвативший крупный объект. Профилировщики вроде memray — следующий шаг, если tracemalloc не видит памяти C-расширений
📚 Что почитать
- Garbage Collector interface — пороги,
freezeдля пре-форк серверов и пометки об откате в 3.14.5 - Garbage collector design — внутренняя документация CPython: как сборщик вычитает внутренние ссылки и какие объекты отслеживает
- Memory Management — pymalloc, размеры арен и переменная
PYTHONMALLOC - tracemalloc — снимки,
compare_toи группировка по traceback