Ciclos de retención: causas y detección

Un ciclo de retención ocurre cuando dos o más objetos mantienen referencias strong entre sí, lo que impide que ARC llegue a un contador de cero y provoca una fuga de memoria.

```swift class Owner { var pet: Pet? } class Pet { var owner: Owner? } var o: Owner? = Owner() var p: Pet? = Pet() o?.pet = p // Owner → Pet (strong) p?.owner = o // Pet → Owner (strong) o = nil; p = nil // Neither deinit called — cycle! ```

```swift class Node { var children: [Node] = [] var parent: Node? // strong → cycle with parent } let root = Node() let child = Node() root.children.append(child) child.parent = root // cycle ```

```swift class ViewController { var onComplete: (() -> Void)? func setup() { onComplete = { // closure strongly captures self self.doWork() // ← cycle! } } } ```

```swift protocol TaskDelegate: AnyObject { func didFinish() } class Task { var delegate: TaskDelegate? // if strong → potential cycle } class Manager: TaskDelegate { var task = Task() init() { task.delegate = self } // Manager → Task → Manager } ```

Use Xcode Instruments → Leaks: 1. Ejecute la aplicación en Instruments 2. Haga clic en el instrumento Leaks 3. Las marcas rojas indican objetos filtrados 4. Examine los detalles para ver el grafo de referencias Como alternativa, establezca `deinit { print(...) }` y compruebe si se ejecuta.

En el depurador de Xcode: Debug > Memory Graph Debugger. Haga clic en un objeto filtrado para ver su cadena de referencias; el ciclo aparecerá como un bucle cerrado en el grafo.

• Un delegate que almacena otro delegate mediante una referencia strong • Un closure que captura `self` mediante una referencia strong • Referencias strong bidireccionales entre padre e hijo • Un observador de NotificationCenter que mantiene un closure que captura self • El target de un Timer es `self` (strong)

```swift class Poller { var timer: Timer? func start() { timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [weak self] _ in self?.poll() // weak self breaks cycle } } deinit { timer?.invalidate() } } ```

```swift class Listener { var token: NSObjectProtocol? init() { token = NotificationCenter.default.addObserver(forName: .UIApplicationDidBecomeActive, object: nil, queue: .main) { [weak self] _ in self?.refresh() } } deinit { NotificationCenter.default.removeObserver(token!) } } ```

Puntos clave: • Ciclos de retención: referencias strong mutuas → ninguno de los objetos se desasigna • Comunes en: delegates, closures y vínculos bidireccionales entre padre e hijo • Detectarlos con Instruments Leaks o Xcode Memory Graph Debugger • Solucionarlos con referencias `weak` o `unowned` • Los temporizadores y NotificationCenter también pueden causar ciclos: rómpalos con `[weak self]` Siguiente tema: referencias weak y unowned.