Перейти на PRO

Что такое циклические ссылки в Python и как с ними бороться

Тип вопроса: Python Вероятность: 10% Категория: Python Разработчик

Ответ

Циклическая ссылка (reference cycle) — это ситуация в управлении памятью, когда два или более объекта ссылаются друг на друга, создавая замкнутый цикл сильных ссылок. Это мешает сборщику мусора освободить память, занимаемую этими объектами, что приводит к утечкам памяти.

Почему это проблема?

Стандартный механизм сборки мусора в Python (подсчёт ссылок) не может обработать циклы. Когда счётчик ссылок на объект падает до нуля, объект удаляется. В цикле счётчики ссылок объектов никогда не достигнут нуля, даже если на них больше нет ссылок извне цикла.

Хотя в Python есть дополнительный циклический сборщик мусора (cyclic GC), который находит и удаляет такие циклы, он работает периодически и не может разрешить циклы, если в них есть объекты с методом __del__.

Пример создания цикла:

class Node:
    def __init__(self, name):
        self.name = name
        self.parent = None
        print(f"Node {self.name} created")

    def __del__(self):
        # Этот метод усложняет работу циклического GC
        print(f"Node {self.name} destroyed")

# Создаем два объекта
a = Node('A')
b = Node('B')

# Создаем циклическую ссылку: a ссылается на b, а b на a
a.parent = b
b.parent = a

# Удаляем внешние ссылки на объекты
del a
del b

# Сообщение "destroyed" не будет выведено, объекты остались в памяти

Как бороться с циклическими ссылками?

Основной способ — использовать слабые ссылки с помощью модуля weakref. Слабая ссылка не увеличивает счётчик ссылок объекта, что позволяет разорвать цикл.

Решение с помощью weakref:

import weakref

class Node:
    def __init__(self, name):
        self.name = name
        # Храним слабую ссылку на родителя
        self._parent_ref = None
        print(f"Node {self.name} created")

    @property
    def parent(self):
        return self._parent_ref() if self._parent_ref else None

    @parent.setter
    def parent(self, parent_node):
        self._parent_ref = weakref.ref(parent_node) if parent_node else None

    def __del__(self):
        print(f"Node {self.name} destroyed")

# Создаем объекты
a = Node('A')
b = Node('B')

# Создаем ссылки (одна из них слабая)
a.parent = b
b.parent = a # Эта ссылка будет слабой

del a
del b

# Теперь оба сообщения "destroyed" будут выведены, утечки памяти нет

Другой подход — явный разрыв цикла перед удалением объектов, например, вызвав b.parent = None.

Ответ 18+ 🔞

А, слушай, вот эта циклическая ссылка — это такая классическая засада, блядь! Представь себе двух мудаков, которые держат друг друга за жопу над пропастью. Каждый думает: «Я ж его держу, не упаду!» А на самом деле они оба висят, и если никто со стороны не подойдёт и не даст пинка, так и будут висеть до скончания времён, память жрут.

И в чём же, нахуй, проблема?

Ну, обычный счётчик ссылок в Python — он тупой, как пробка. Видит, что на объект A ссылается B, а на B ссылается A. Счётчики у обоих по единице. И всё, приехали. Даже если ты, как программист, уже давно забыл про эти объекты и удалил все внешние ссылки (del a, del b), они друг друга в памяти держат, как два алкаша у подъезда. Циклический сборщик мусора, конечно, иногда приходит и разнимает эту пьяную драку, но если у объектов есть метод __del__ — это уже пипец, он пасует. Не может решить, кого удалять первым, и бросает всё нахуй.

Вот тебе наглядный пиздец:

class Node:
    def __init__(self, name):
        self.name = name
        self.parent = None
        print(f"Node {self.name} created")

    def __del__(self):
        # Этот метод усложняет работу циклического GC
        print(f"Node {self.name} destroyed")

# Создаем два объекта
a = Node('A')
b = Node('B')

# Создаем циклическую ссылку: a ссылается на b, а b на a
a.parent = b
b.parent = a

# Удаляем внешние ссылки на объекты
del a
del b

# Сообщение "destroyed" не будет выведено, объекты остались в памяти

Запустишь — и нихуя не удалится. Сидят два призрака в оперативке и тихо ебут тебе мозг утечкой памяти.

Как с этим ебеней бороться?

Главное оружие — слабые ссылки, модуль weakref. Это как дать мудакам в нашей аналогии не держаться за жопу, а просто кивать друг другу: «Я тебя вроде как знаю». Слабая ссылка не увеличивает счётчик, поэтому когда внешние ссылки пропадают — цикл рвётся, и сборщик мусора может спокойно всех похоронить.

Решение через weakref — красота, блядь:

import weakref

class Node:
    def __init__(self, name):
        self.name = name
        # Храним слабую ссылку на родителя
        self._parent_ref = None
        print(f"Node {self.name} created")

    @property
    def parent(self):
        return self._parent_ref() if self._parent_ref else None

    @parent.setter
    def parent(self, parent_node):
        self._parent_ref = weakref.ref(parent_node) if parent_node else None

    def __del__(self):
        print(f"Node {self.name} destroyed")

# Создаем объекты
a = Node('A')
b = Node('B')

# Создаем ссылки (одна из них слабая)
a.parent = b
b.parent = a # Эта ссылка будет слабой

del a
del b

# Теперь оба сообщения "destroyed" будут выведены, утечки памяти нет

Вот теперь работает как часы. Удалились оба, память чиста. Можно, конечно, и вручную цикл рвать, типа b.parent = None перед удалением, но это ж надо помнить, а мы, программисты, народ забывчивый, ёпта. Лучше сразу архитектуру делать без таких костылей.

© ХакСобесов, 2026
support@hacksobesov.com