Краткий ответ

Замыкание удерживает объект через ячейку замыкания — специальную область, содержащую значение переменной из внешней функции. Пока сохранённый обратный вызов ссылается на эту ячейку, объект остаётся достижимым и не освобождается.

Чтобы отпустить память, нужно устранить ссылку: переназначить захваченную переменную на небольшое значение, удалить сам обратный вызов из реестра или использовать слабую ссылку, если это допустимо.

Исторический контекст

Замыкания появились как механизм лексической области видимости: вложенная функция может использовать переменные функции, в которой она создана, даже после завершения внешнего вызова. Это удобно для обработчиков событий, фабрик функций и конфигурируемых обратных вызовов.

Цена удобства — увеличенный срок жизни захваченных объектов. Обратный вызов становится владельцем не только своего кода, но и ячеек с переменными внешней функции.

Постановка проблемы

Фабрика может загрузить большой буфер, создать обработчик, использующий этот буфер, и вернуть обработчик. Если обработчик затем помещён в долгоживущий реестр, очередь или диспетчер событий, буфер будет жить столько же, сколько и обработчик.

Удаление локального имени во внешнем вызывающем коде не помогает: это удаляет только одну ссылку. Если переменная захвачена замыканием, её значение продолжает находиться в ячейке, доступной через объект функции.

Последствия — рост потребления памяти, удержание больших графов объектов и снижение эффективности сборки мусора. Особенно опасен этот эффект при регистрации множества обработчиков для временных данных.

Подробное решение

При компиляции вложенной функции переменная из внешней области, используемая во вложенной функции, становится свободной переменной. Python хранит её в объекте-ячейке, а функция хранит ссылку на эту ячейку через своё замыкание.


def make_handler(payload):
    def handle(event):
        return len(payload)
    return handle

handler = make_handler(bytearray(10_000_000))
# Большой объект удерживается через handler.__closure__.
handler = None  # после этого цепочка ссылок разрывается

После возврата из make_handler обычная локальная область видимости исчезает, но ячейка продолжает существовать, поскольку на неё ссылается handle. Пока handler доступен, доступен и объект payload.

Безопасный способ освобождения — не захватывать большой объект целиком. Вместо этого можно захватить идентификатор и получать данные из управляемого хранилища во время вызова. Такой вариант уменьшает удержание памяти, но добавляет обращение к хранилищу и необходимость обрабатывать отсутствие записи.

Иногда подходит weakref, если объект поддерживает слабые ссылки и обработчик не должен продлевать его жизнь. Это предотвращает удержание, но требует корректной обработки ситуации, когда объект уже уничтожен. Для объектов вроде некоторых встроенных контейнеров слабые ссылки недоступны.

Присваивание None захваченной переменной также разрывает ссылку, но делать это нужно явно внутри области, где переменная является захваченной. Простое удаление внешнего имени после создания обработчика не меняет содержимое ячейки замыкания.

Важно отличать удержание замыканием от циклической ссылки. В обычном случае объект освобождается подсчётом ссылок, когда исчезает последняя ссылка. Если замыкание участвует в цикле, дополнительно может потребоваться сборщик циклического мусора.

Ситуация из практики

В сервисе обработки документов для каждого задания создавался обработчик, замыкающий большой разобранный документ. Обработчики регистрировались в диспетчере до завершения задания, поэтому документы оставались в памяти даже после отправки результата.

Рассматривались три варианта. Принудительный вызов сборщика мусора не решал проблему: документы оставались достижимыми. Хранение слабых ссылок уменьшало удержание, но требовало обработки исчезнувших документов и не подходило для обязательных данных. Удаление обработчика после завершения задания было простым, но требовало гарантированного удаления во всех ветках обработки.

Выбрали явное снятие обработчика в блоке завершения задания и передачу в обработчик только идентификатора документа. В результате жизненный цикл данных стал совпадать с жизненным циклом задания, а диспетчер перестал быть скрытым владельцем больших объектов.

Что кандидаты часто упускают

Захватывает ли замыкание значение или переменную?

В Python замыкание обычно захватывает не отдельную копию значения, а ячейку переменной. Поэтому последующее переназначение переменной может изменить результат работы уже созданного обработчика. Это также объясняет эффект позднего связывания в циклах: несколько функций могут читать одну и ту же ячейку после завершения цикла.
Освободит ли del большого объекта память, если есть замыкание?

del удаляет конкретную привязку имени, но не уничтожает объект при наличии других ссылок. Если объект находится в ячейке замыкания, удаление внешнего имени его не освобождает. Нужно изменить содержимое ячейки, удалить функцию, удерживающую замыкание, или разорвать всю цепочку ссылок.
Может ли замыкание удерживать больше, чем явно захваченный объект?

Да. Захваченный объект может ссылаться на контейнер, атрибуты, кэш или целый граф связанных объектов. Например, замыкание небольшого узла может косвенно удерживать большой документ или контекст запроса. Поэтому при расследовании утечки нужно анализировать цепочку ссылок до корневого владельца, а не только размер самой ячейки замыкания.