Как удалить объекты из памяти при retain cycle?

Управление памятью и Retain Cycles в iOS

Retain cycle (циклическая сильная ссылка) — одна из наиболее распространенных проблем управления памятью в iOS разработке при использовании ARC (Automatic Reference Counting). Это происходит, когда два или более объекта удерживают сильные ссылки друг на друга, создавая замкнутый цикл, который предотвращает их освобождение даже после того, как они больше не нужны.

Основные подходы к устранению retain cycles

1. Weak References (Слабые ссылки)

Слабые ссылки не увеличивают счетчик ссылок объекта и автоматически становятся nil, когда объект освобождается. Используются через ключевое слово weak.

class Parent {
    var child: Child?
    deinit { print("Parent освобожден") }
}

class Child {
    weak var parent: Parent? // Weak reference для разрыва цикла
    deinit { print("Child освобожден") }
}

var parent: Parent? = Parent()
var child: Child? = Child()

parent?.child = child
child?.parent = parent

parent = nil // Оба объекта освобождаются
child = nil

2. Unowned References (Бессобственные ссылки)

Аналогичны weak ссылкам, но не становятся nil при освобождении объекта. Используются, когда объект имеет одинаковый или более длительный жизненный цикл.

class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) { self.name = name }
    deinit { print("Customer \(name) освобожден") }
}

class CreditCard {
    let number: String
    unowned let customer: Customer // Unowned reference
    init(number: String, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("CreditCard \(number) освобожден") }
}

3. Использование Capture Lists в замыканиях

Замыкания в Swift захватывают ссылки на объекты, что часто приводит к retain cycles. Решение — использовать списки захвата с weak или unowned.

class NetworkManager {
    var onCompletion: (() -> Void)?
    
    func fetchData() {
        // Использование weak self
        let task = URLSession.shared.dataTask(with: someURL) { [weak self] data, response, error in
            guard let self = self else { return } // Опциональное разворачивание
            self.processData(data)
            self.onCompletion?()
        }
        task.resume()
    }
    
    func processData(_ data: Data?) {
        // Обработка данных
    }
    
    deinit { print("NetworkManager освобожден") }
}

Практические стратегии предотвращения retain cycles

• Анализ отношений между объектами: Всегда анализируйте, могут ли два объекта ссылаться друг на друга. Если да — используйте weak или unowned.
• Использование инструментов анализа:
  • Instruments Leak Check в Xcode
  • Visual Debug Memory Graph (красные стрелки указывают на retain cycles)
  • Swift Linter tools для статического анализа кода
• Паттерн делегирования: Всегда объявляйте делегаты как weak свойства

protocol SomeDelegate: AnyObject {}
class SomeClass {
    weak var delegate: SomeDelegate?
}

• Аккуратное использование self в замыканиях: Всегда используйте capture lists при обращении к self внутри замыканий
• Проверка deinit методов: Добавляйте логирование в deinit для отслеживания освобождения объектов

Типичные сценарии возникновения retain cycles

1. Делегаты и протоколы (без weak ссылок)
2. Замыкания, захватывающие self
3. Таймеры (особенно Timer.scheduledTimer)
4. Уведомления (NotificationCenter без удаления наблюдателей)
5. KVO-наблюдатели без правильной отписки

Пример комплексного решения

class ViewController: UIViewController {
    private var dataManager: DataManager?
    private var timer: Timer?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupDataManager()
        setupTimer()
        setupNotificationObserver()
    }
    
    private func setupDataManager() {
        dataManager = DataManager()
        dataManager?.onDataUpdate = { [weak self] data in
            self?.updateUI(with: data)
        }
    }
    
    private func setupTimer() {
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
            self?.refreshData()
        }
    }
    
    private func setupNotificationObserver() {
        NotificationCenter.default.addObserver(
            forName: .userDidUpdate,
            object: nil,
            queue: .main
        ) { [weak self] notification in
            self?.handleNotification(notification)
        }
    }
    
    deinit {
        timer?.invalidate()
        NotificationCenter.default.removeObserver(self)
        print("ViewController освобожден")
    }
}

Заключение

Устранение retain cycles — критически важный навык для iOS разработчика. Основные инструменты — weak и unowned ссылки, правильное использование capture lists в замыканиях, и тщательный анализ отношений между объектами. Регулярное использование инструментов отладки памяти и внимание к архитектурным решениям помогут предотвратить утечки памяти и обеспечить стабильную работу приложения.