Retain Cycle — podstata, příčiny vzniku a odstranění ve vývoji aplikací

Co je Retain Cycle?

Retain Cycle — je situace, kdy dva nebo více objektů vlastní jeden druhého prostřednictvím strong referencí, čímž vytvářejí uzavřený graf závislostí. ARC nemůže uvolnit žádný z těchto objektů, protože retain count každého z nich je vždy ≥ 1: objekt A drží B, B drží A a jejich čítače se nikdy nevynulují.

Problém vzniká výhradně v systémech s počítáním referencí (ARC, MRR). V Garbage Collection určuje kolektor nedosažitelnost na základě grafu referencí z kořenové množiny (root set) — cykly nejsou překážkou. V ARC je však cyklus ekvivalentní úniku, protože deterministické uvolňování založené na čítači nemůže vyřešit kruhovou závislost.

Podle WWDC 2012 Session 406 je retain cycle nejčastější příčinou úniků paměti v Objective-C a Swift aplikacích. Typické scénáře: parent-child vztahy s delegáty, uzávěry zachycující self a vrstvené architektury s obousměrnými vazbami.

Příklady retain cycle ve vývoji pro iOS

Podívejme se na klasické scénáře retain cycle, se kterými se setkává každý iOS vývojář. Pochopení těchto vzorů je základem pro psaní bezpečného kódu s ARC.

Parent-Child s delegátem

Klasický scénář: rodičovský objekt (např. UIViewController) vytvoří podřízený objekt a stane se jeho delegátem. Pokud oba používají strong reference, vzniká retain cycle. Řešení — delegát musí být weak.

// CHYBA: retain cycle prostřednictvím strong delegate
protocol ChildDelegate: AnyObject { }

class ParentVC: UIViewController, ChildDelegate {
    var child: ChildVC?

    func showChild() {
        child = ChildVC()
        child?.delegate = self        // Parent → Child (strong)
    }                                 // Child → Parent (strong prostřednictvím delegate)
}                                     // ⚠️ Retain cycle!

class ChildVC: UIViewController {
    var delegate: ChildDelegate?    // ❌ strong ve výchozím nastavení
}

// OPRAVA: weak delegate
class ChildVC: UIViewController {
    weak var delegate: ChildDelegate? // ✅ weak — nedrží
}

V příkladu ParentVC drží strong referenci na ChildVC prostřednictvím vlastnosti child. ChildVC drží strong referenci na ParentVC prostřednictvím delegate. Cyklus je uzavřen. Oprava: weak var delegate — reference nezvyšuje retain count a ParentVC může být uvolněn.

NSTimer a retain cycle

NSTimer — klasický zdroj retain cycle. Timer drží target (obvykle self) a target drží timer prostřednictvím vlastnosti. I když je timer jednorázový, neuvolní se do invalidate. Řešení: vždy volejte timer.invalidate() v deinit nebo viewDidDisappear.

Vrstvené architektury

V architekturách s kaskádovým vlastnictvím (koordinátory, routery) často vznikají vícestupňové cykly: Coordinator → ViewController → ViewModel → Coordinator (prostřednictvím callbacku). Každá strong reference v řetězci musí být vědomě zvolena — jedna weak reference v kterémkoli článku přeruší cyklus.

Retain Cycle v Swift uzávěrech

Uzávěry (closures) ve Swift zachycují externí proměnné pomocí strong reference. Pokud je uzávěra uložena jako vlastnost objektu (např. completion handler) a zachycuje self, vzniká retain cycle: self → closure → self.

Toto je nejčastější zdroj retain cycle v moderním Swift vývoji. Vzniká implicitně — vývojář si nemusí všimnout zachycení self v uzávěře, zejména při použití zkrácené syntaxe bez explicitního self.

class DownloadService {
    var onComplete: ((Data) -> Void)?
    var result: Data?

    func startDownload() {
        // ❌ Retain cycle: self → onComplete → self
        onComplete = { data in
            self.result = data
            self.notifyUI()
        }

        // ✅ Oprava: capture list s weak self
        onComplete = { [weak self] data in
            guard let self else { return }
            self.result = data
            self.notifyUI()
        }
    }

    func notifyUI() { }
}

Capture list [weak self] vytváří slabou referenci na self uvnitř uzávěry. Pokud je DownloadService uvolněn před provedením uzávěry, self se stane nil a kód bezpečně vystoupí přes guard. Toto je standardní vzor pro asynchronní uzávěry ve Swift — měl by být vždy aplikován, když je uzávěra uložena jako vlastnost.

Unowned self v uzávěrech

unowned self — alternativa k weak self, když self garantovaně žije déle než uzávěra. Příklad: synchronní uzávěra, která se provádí okamžitě (sorted, filter). V takových případech je self určitě živé a unowned je bezpečný. Nicméně unowned crashuje při přístupu k uvolněnému objektu — proto je weak považován za bezpečnou volbu ve výchozím nastavení.

Jak odhalit retain cycle: diagnostické nástroje

Včasné odhalení retain cycle je klíčové pro výkon aplikace. Podívejme se na hlavní nástroje a metody identifikace cyklických referencí ve vývoji pro iOS.

Xcode Memory Debugger

Xcode Memory Debugger (Debug Memory Graph) — vizuální nástroj zobrazující graf objektů v paměti s jejich referencemi. Retain cycle se zobrazuje jako uzavřený řetězec strong šipek. Pro spuštění: klikněte na tlačítko Debug Memory Graph v panelu Debug area během běhu aplikace. Každý objekt je zobrazen s typem, adresou a seznamem referencí.

Instruments Leaks

Instruments Leaks — profiler pro automatické odhalování úniků. Zaznamenává alokace a analyzuje graf referencí v reálném čase. Odhaluje nejen retain cycle, ale také zapomenuté reference, neuvolněné ViewControllery a další úniky. Leaks ukazuje přesný objekt a řetězec držení.

Logování deinit

Nejjednodušší způsob — přidejte print do deinit každé klíčové třídy. Pokud deinit není volán při očekávaném zničení objektu — existuje retain cycle. Tato metoda nevyžaduje nástroje a je účinná pro počáteční diagnostiku.

Doporučený přístup: používejte deinit logování ve fázi vývoje, Memory Debugger — při ručním testování, Instruments Leaks — v CI/CD pipeline pro automatickou regresní kontrolu úniků.

Prevence retain cycle a best practices

Předcházet retain cycle je snazší než jej opravovat v produkci. Několik pravidel, která minimalizují riziko cyklických referencí.

Pravidlo weak delegate

Všichni delegáti a dataSource musí být weak. Toto pravidlo je zabudováno do UIKit: všechny delegátské protokoly v Apple SDK jsou deklarovány s weak vlastnostmi (UITableView.delegate, UICollectionView.dataSource). Pro vlastní protokoly používejte weak var delegate: MyDelegate? a dědění protokolu po AnyObject.

Capture list v uzávěrech

Každá uzávěra, která je uložena jako vlastnost (completion handler, callback) a zachycuje self, musí používat [weak self] v capture list. Výjimka — uzávěry, které se provádějí okamžitě a nejsou ukládány (sorted, map, filter). Pro ně je unowned self bezpečný.

Kontrola architektury

Ve složitých architekturách (VIPER, Coordinators, Redux) sledujte směr strong referencí. Vlastník drží strong referenci na podřízeného, ale podřízený by měl odkazovat na vlastníka pouze prostřednictvím weak nebo unowned. Jednosměrný tok dat (unidirectional data flow) zjednodušuje kontrolu referencí.

// Příklad: kontrola s logováním deinit
class BaseViewController: UIViewController {
    deinit {
        print("✅ \(type(of: self)) deallocated")
    }
}

// Použití: všechny ViewControllery dědí BaseViewController
class ProfileVC: BaseViewController {
    var viewModel: ProfileViewModel?
    var onLogout: (() -> Void)?

    override func viewDidLoad() {
        super.viewDidLoad()
        onLogout = { [weak self] in
            self?.dismiss(animated: true)
        }
    }
}
// Při zavření ProfileVC očekáváme v konzoli „✅ ProfileVC deallocated”

Základní třída s logováním deinit poskytuje okamžitou zpětnou vazbu. Pokud se zpráva neobjeví při očekávaném zavření obrazovky — v této třídě je retain cycle. Přidejte tuto praktiku do šablony projektu pro všechny ViewControllery.