Что такое Reference Cycle?

Что такое Reference Cycle (Цикл сильных ссылок)

Reference Cycle (цикл сильных ссылок, также часто называемый retain cycle) — это проблема в управлении памятью, возникающая в языках с подсчётом ссылок (ARC — Automatic Reference Counting), таких как Swift и Objective-C, когда два или более объекта удерживают друг друга через сильные ссылки (strong references), создавая замкнутый цикл зависимостей. В результате система не может освободить память, занимаемую этими объектами, даже когда они больше не нужны, что приводит к утечке памяти (memory leak).

Механизм возникновения

В ARC каждый объект имеет счётчик ссылок. Когда на объект создаётся сильная ссылка, счётчик увеличивается на 1. Когда ссылка уничтожается (например, переменная выходит из области видимости или ей присваивается nil), счётчик уменьшается на 1. Объект удаляется из памяти, когда счётчик достигает нуля. Цикл возникает, если:

1. Объект A имеет сильную ссылку на объект B.
2. Объект B имеет сильную ссылку на объект A.
3. Внешние ссылки на оба объекта исчезают, но их внутренние взаимные ссылки сохраняют счётчики больше нуля.

Пример на Swift:

class Person {
    var name: String
    var apartment: Apartment? // Сильная ссылка на Apartment
    init(name: String) {
        self.name = name
    }
}

class Apartment {
    var unit: String
    var tenant: Person? // Сильная ссылка на Person
    init(unit: String) {
        self.unit = unit
    }
}

// Создание объектов
var john: Person? = Person(name: "John")
var unit4A: Apartment? = Apartment(unit: "4A")

// Создание цикла сильных ссылок
john?.apartment = unit4A
unit4A?.tenant = john

// Попытка освободить объекты
john = nil // Счётчик Person остаётся 1 (удерживается Apartment.tenant)
unit4A = nil // Счётчик Apartment остаётся 1 (удерживается Person.apartment)
// Оба объекта остаются в памяти навсегда!

Последствия цикла сильных ссылок

• Утечки памяти: Объекты никогда не освобождаются, что увеличивает потребление памяти.
• Снижение производительности: Приложение может замедлиться или завершиться аварийно из-за нехватки памяти.
• Непредсказуемое поведение: Удержанные объекты могут продолжать выполнять фоновые задачи (например, таймеры или сетевые запросы).

Решение проблемы

В Swift используются слабые (weak) и бесхозные (unowned) ссылки, которые не увеличивают счётчик ссылок:

• weak: Используется, когда ссылка может стать nil. Всегда объявляется как var и optional (?).
• unowned: Используется, когда ссылка никогда не станет nil (например, при жёстких архитектурных гарантиях). Не является optional.

Исправленный пример:

class Apartment {
    var unit: String
    weak var tenant: Person? // Слабая ссылка разрывает цикл
    init(unit: String) {
        self.unit = unit
    }
}
// Теперь при john = nil и unit4A = nil объекты корректно освобождаются.

Типичные сценарии появления циклов

1. Делегаты (delegates): Ссылки между контроллером и его делегатом.
2. Замыкания (closures): Захват self внутри замыкания без использования [weak self] или [unowned self].
3. Родительско-дочерние связи: Например, между view controller и его дочерними view.
4. Наблюдатели (observers): Объекты в паттерне Observer.

Пример с замыканием:

class DataHandler {
    var data: [String] = []
    lazy var processData: () -> Void = {
        // Захват self создаёт цикл, так как замыкание удерживается self
        self.data.append("Processed")
    }
    deinit {
        print("DataHandler освобождён")
    }
}
// Решение: использовать [weak self]
lazy var processData: () -> Void = { [weak self] in
    self?.data.append("Processed")
}

Профилактика и инструменты

• Использование weak и unowned в соответствии с семантикой отношений.
• Анализ кода: Внимание к связям между классами и замыканиям.
• Инструменты отладки:
  • Instruments (Leaks, Allocations) в Xcode.
  • Визуализация памяти в Debug Memory Graph.
  • Логирование в deinit.

Заключение

Циклы сильных ссылок — критическая проблема в iOS-разработке, требующая внимания при проектировании отношений между объектами. Правильное использование типов ссылок и регулярная проверка кода с помощью инструментов отладки позволяют избежать утечек памяти и создавать стабильные приложения. В сложных архитектурах (например, с RxSwift или Combine) стоит также учитывать циклы в подписках, используя disposable-механизмы.