Retain Cycle — essentie, oorzaken en oplossing in app-ontwikkeling

Wat is een Retain Cycle?

Retain Cycle — is een situatie waarin twee of meer objecten elkaar vasthouden via strong-referenties, waardoor een gesloten afhankelijkheidsgraaf ontstaat. ARC kan geen van deze objecten vrijgeven, omdat de retain count van elk altijd ≥ 1 is: object A houdt B vast, B houdt A vast en hun tellers worden nooit gereset.

Het probleem doet zich uitsluitend voor in systemen met referentietelling (ARC, MRR). In Garbage Collection bepaalt de verzamelaar onbereikbaarheid op basis van de referentiegraaf vanuit de wortelverzameling (root set) — cycli vormen geen belemmering. In ARC daarentegen is een cyclus gelijk aan een lek, omdat deterministisch vrijgeven op basis van een teller de circulaire afhankelijkheid niet kan oplossen.

Volgens WWDC 2012 Session 406 is retain cycle de meest voorkomende oorzaak van geheugenlekken in Objective-C- en Swift-applicaties. Typische scenario's: parent-child-relaties met delegates, sluitingen die self vastleggen en gelaagde architecturen met bidirectionele verbindingen.

Voorbeelden van retain cycle in iOS-ontwikkeling

Laten we de klassieke retain cycle-scenario's bekijken waar elke iOS-ontwikkelaar mee te maken krijgt. Inzicht in deze patronen is de basis voor het schrijven van veilige code met ARC.

Parent-Child met delegate

Klassiek scenario: het bovenliggende object (bijv. UIViewController) maakt een onderliggend object aan en wordt de delegate ervan. Als beide strong-referenties gebruiken, ontstaat een retain cycle. Oplossing — de delegate moet weak zijn.

// FOUT: retain cycle via 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 via delegate)
}                                     // ⚠️ Retain cycle!

class ChildVC: UIViewController {
    var delegate: ChildDelegate?    // ❌ strong standaard
}

// CORRECTIE: weak delegate
class ChildVC: UIViewController {
    weak var delegate: ChildDelegate? // ✅ weak — houdt niet vast
}

In het voorbeeld houdt ParentVC een strong-referentie naar ChildVC vast via de eigenschap child. ChildVC houdt een strong-referentie naar ParentVC vast via delegate. De cyclus is gesloten. Correctie: weak var delegate — de referentie verhoogt retain count niet, waardoor ParentVC kan worden vrijgegeven.

NSTimer en retain cycle

NSTimer — een klassieke bron van retain cycle. De timer houdt de target (meestal self) vast, en de target houdt de timer vast via een eigenschap. Zelfs als de timer eenmalig is, wordt hij pas vrijgegeven na invalidate. Oplossing: roep altijd timer.invalidate() aan in deinit of viewDidDisappear.

Gelaagde architecturen

In architecturen met trapsgewijs eigendom (coördinatoren, routers) ontstaan vaak meerstapscycli: Coordinator → ViewController → ViewModel → Coordinator (via callback). Elke strong-referentie in de keten moet bewust worden gekozen — één weak-referentie in elke schakel verbreekt de cyclus.

Retain Cycle in Swift-sluitingen

Sluitingen (closures) in Swift leggen externe variabelen vast via strong-referentie. Als een sluiting wordt opgeslagen als eigenschap van een object (bijv. completion handler) en self vastlegt, ontstaat een retain cycle: self → closure → self.

Dit is de meest voorkomende bron van retain cycle in moderne Swift-ontwikkeling. Het ontstaat impliciet — de ontwikkelaar kan het vastleggen van self in de sluiting over het hoofd zien, vooral bij gebruik van verkorte syntax zonder expliciete 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()
        }

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

    func notifyUI() { }
}

Capture list [weak self] creëert een zwakke referentie naar self binnen de sluiting. Als DownloadService wordt vrijgegeven voordat de sluiting wordt uitgevoerd, wordt self nil en verlaat de code veilig via guard. Dit is het standaardpatroon voor asynchrone sluitingen in Swift — het moet altijd worden toegepast wanneer de sluiting als eigenschap wordt opgeslagen.

Unowned self in sluitingen

unowned self — een alternatief voor weak self, wanneer self gegarandeerd langer leeft dan de sluiting. Voorbeeld: een synchrone sluiting die onmiddellijk wordt uitgevoerd (sorted, filter). In dergelijke gevallen leeft self zeker en is unowned veilig. Echter, unowned crasht bij toegang tot een vrijgegeven object — daarom wordt weak als de veilige standaardkeuze beschouwd.

Hoe retain cycle detecteren: diagnostische hulpmiddelen

Vroegtijdige detectie van retain cycle is cruciaal voor de prestaties van de applicatie. Laten we de belangrijkste hulpmiddelen en methoden bekijken voor het identificeren van cyclische verwijzingen in iOS-ontwikkeling.

Xcode Memory Debugger

Xcode Memory Debugger (Debug Memory Graph) — een visueel hulpmiddel dat de graaf van objecten in het geheugen toont met hun referenties. Een retain cycle wordt weergegeven als een gesloten keten van strong-pijlen. Om te starten: klik op de knop Debug Memory Graph in het Debug area-paneel tijdens het uitvoeren van de applicatie. Elk object wordt getoond met type, adres en lijst van referenties.

Instruments Leaks

Instruments Leaks — een profiler voor automatische detectie van lekken. Registreert allocaties en analyseert de referentiegraaf in realtime. Detecteert niet alleen retain cycles, maar ook vergeten referenties, niet-vrijgegeven ViewControllers en andere lekken. Leaks geeft het exacte object en de retentieketen aan.

Deinit-logging

De eenvoudigste methode — voeg een print toe in deinit van elke belangrijke klasse. Als deinit niet wordt aangeroepen bij de verwachte vernietiging van het object — is er een retain cycle. Deze methode vereist geen hulpmiddelen en is effectief voor initiële diagnostiek.

Aanbevolen aanpak: gebruik deinit-logging in de ontwikkelingsfase, Memory Debugger — bij handmatig testen, Instruments Leaks — in de CI/CD-pipeline voor automatische regressiecontrole van lekken.

Preventie van retain cycle en best practices

Voorkomen van retain cycle is eenvoudiger dan herstellen in productie. Enkele regels die het risico op cyclische verwijzingen tot een minimum beperken.

De weak delegate-regel

Alle delegates en dataSources moeten weak zijn. Deze regel is ingebouwd in UIKit: alle delegate-protocollen in de Apple SDK zijn gedeclareerd met weak-eigenschappen (UITableView.delegate, UICollectionView.dataSource). Gebruik voor eigen protocollen weak var delegate: MyDelegate? en laat het protocol overerven van AnyObject.

Capture list in sluitingen

Elke sluiting die als eigenschap wordt opgeslagen (completion handler, callback) en self vastlegt, moet [weak self] gebruiken in de capture list. Uitzondering — sluitingen die onmiddellijk worden uitgevoerd en niet worden opgeslagen (sorted, map, filter). Daarvoor is unowned self veilig.

Architectuur controleren

In complexe architecturen (VIPER, Coordinators, Redux) moet u de richting van strong-referenties volgen. De eigenaar houdt een strong-referentie naar de ondergeschikte vast, maar de ondergeschikte mag alleen via weak of unowned naar de eigenaar verwijzen. Unidirectionele gegevensstroom (unidirectional data flow) vereenvoudigt de controle van referenties.

// Voorbeeld: controle met deinit-logging
class BaseViewController: UIViewController {
    deinit {
        print("✅ \(type(of: self)) deallocated")
    }
}

// Gebruik: alle ViewControllers erven van BaseViewController
class ProfileVC: BaseViewController {
    var viewModel: ProfileViewModel?
    var onLogout: (() -> Void)?

    override func viewDidLoad() {
        super.viewDidLoad()
        onLogout = { [weak self] in
            self?.dismiss(animated: true)
        }
    }
}
// Bij sluiten van ProfileVC verwachten we „✅ ProfileVC deallocated” in de console

Een basisklasse met deinit-logging geeft onmiddellijke feedback. Als het bericht niet verschijnt bij het verwachte sluiten van het scherm — bevat deze klasse een retain cycle. Voeg deze praktijk toe aan het projectsjabloon voor alle ViewControllers.