Ciclos de retenção: causas e detecção

Um ciclo de retenção ocorre quando dois ou mais objetos mantêm referências fortes uns aos outros, impedindo que o ARC chegue a uma contagem zero — o que causa um vazamento de memória.

```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 → Vazamentos: 1. Execute o aplicativo no Instruments 2. Clique no instrumento Vazamentos 3. As marcações vermelhas indicam objetos vazados 4. Explore os detalhes para ver o grafo de referências Como alternativa, defina `deinit { print(...) }` e verifique se ele é executado.

No depurador do Xcode: Depurar > Depurador do Grafo de Memória. Clique em um objeto vazado para ver sua cadeia de referências — o ciclo ficará visível como um circuito fechado no grafo.

• Delegado armazenando outro delegado com uma referência forte • Fechamento capturando `self` com uma referência forte • Referências fortes bidirecionais entre pai e filho • Observador do NotificationCenter mantendo um fechamento que captura `self` • O alvo do temporizador é `self` (forte)

```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!) } } ```

Principais conclusões: • Ciclos de retenção: referências fortes mútuas → nenhum objeto é desalocado • Comuns em: delegados, fechamentos e vínculos bidirecionais entre pai e filho • Detecte com o Leaks do Instruments ou o Depurador de Gráfico de Memória do Xcode • Corrija com referências `weak` ou `unowned` • Temporizadores e NotificationCenter também causam ciclos — interrompa-os com `[weak self]` Próximo: referências weak e unowned.