В чем разница между Retain Cycle и Memory Link?

Разница между Retain Cycle и Memory Leak

Хотя термины Retain Cycle и Memory Leak в контексте iOS-разработки тесно связаны, они описывают разные, но взаимосвязанные концепции в управлении памятью. Понимание различий критически важно для написания стабильных и эффективных приложений.

Что такое Memory Leak (Утечка памяти)?

Утечка памяти — это более общее понятие, обозначающее ситуацию, когда выделенная память не освобождается, хотя объект больше не используется приложением. Это приводит к постоянному росту потребления памяти (RAM), что в конечном итоге может вызвать предупреждения системы, падение производительности (фризы, лаги) и termination due to memory pressure (принудительное завершение приложения iOS).

Причины утечек памяти:

• Retain cycles (сильные циклические ссылки) — самая частая причина в ARC (Automatic Reference Counting).
• Неправильная работа с Core Foundation объектами (например, CGImageRef, CFArrayRef) без ручного управления памятью (CFRetain/CFRelease).
• Незарегистрированные observers (например, для NotificationCenter или KVO).
• Удержание сильных ссылок на объекты в замыканиях (closures), которые сами захвачены этими объектами.
• "Забытые" таймеры (Timer), созданные без использования слабых ссылок.

// Пример утечки НЕ через классический retain cycle
class ImageLoader {
    var onComplete: ((UIImage?) -> Void)?
    
    func loadImage(from url: URL) {
        URLSession.shared.dataTask(with: url) { data, _, _ in
            let image = UIImage(data: data ?? Data())
            DispatchQueue.main.async {
                self.onComplete?(image) // Замыкание сильно захватывает `self`
            }
        }.resume()
    }
}
// Если экземпляр `ImageLoader` будет деаллоцирован ДО вызова замыкания,
// `self` внутри замыкания станет висячим указателем, но технически
// утечка здесь может произойти из-за удержания задачи сессии.

Что такое Retain Cycle (Циклическая ссылка)?

Retain Cycle (Циклическая сильная ссылка) — это конкретный механизм возникновения утечки памяти в среде с автоматическим подсчетом ссылок (ARC). Он происходит, когда два или более объекта удерживают (retain) сильные (strong) ссылки друг на друга, образуя замкнутый цикл. Из-за этого счетчик ссылок каждого объекта никогда не достигает нуля, и они никогда не деаллоцируются.

Классические сценарии retain cycle:

1. Два объекта взаимно ссылаются друг на друга.

   class Person {
       let name: String
       var apartment: Apartment? // Сильная ссылка
       init(name: String) { self.name = name }
   }
   
   class Apartment {
       let unit: String
       var tenant: 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 // RETAIN CYCLE!
   
   john = nil
   unit4A = nil
   // Объекты НЕ освободятся, счетчики ссылок = 1.
   

2. Объект хранит сильную ссылку на замыкание, а замыкание сильно захватывает (self) этот объект.

   class MyViewController: UIViewController {
       var closure: (() -> Void)?
       
       override func viewDidLoad() {
           super.viewDidLoad()
           // Замыкание сильно захватывает self, а self владеет closure.
           closure = {
               self.view.backgroundColor = .red // RETAIN CYCLE!
           }
       }
   }
   

Ключевые различия

Как бороться и предотвращать?

1. Для разрыва retain cycles:

    *   Используйте **weak references (`weak`)** для ссылок, которые не должны "владеть" целевым объектом (например, `delegate`, `dataSource`, дочерние ссылки на родителя).
    *   Используйте **unowned references (`unowned`)** когда время жизни объектов четко связано и ссылка никогда не станет `nil` после инициализации. Рискованно, если объект может деаллоцироваться первым.
    *   В замыканиях используйте **capture lists** (списки захвата).

```swift
// Правильное использование weak в замыкании
networkService.fetchData { [weak self] result in
    guard let self = self else { return } // Опциональное разворачивание
    self.updateUI(with: result)
}

// Правильная связь объектов
class Person {
    var apartment: Apartment?
}
class Apartment {
    weak var tenant: Person? // Weak ссылка разрывает цикл!
}
```

2. Для предотвращения утечек в целом:

    *   Помимо борьбы с циклами, всегда следите за жизненным циклом **наблюдателей (observers)**, **таймеров** и **слушателей уведомлений**.
    *   При работе с Core Foundation API используйте **CFRetain** и **CFRelease** или аннотации **`CF_RETURNS_RETAINED`/`CF_RETURNS_NOT_RETAINED`**.
    *   Регулярно проводите **профилирование приложения** с помощью **Xcode Instruments** (шаблоны **Leaks** и **Allocations**), особенно проверяя рост числа "Persistent" объектов после повторения сценариев.

Вывод: Retain Cycle — это самая распространенная причина Memory Leak в iOS-приложениях на Swift/Objective-C. Не каждый memory leak обязательно вызван retain cycle, но практически каждый retain cycle неизбежно приводит к memory leak. Понимание этого различия позволяет целенаправленно искать корень проблемы и применять правильные методы решения.