Swift Academy · Lektion

Retain Cycles: Ursachen und Erkennung

Erkennen Sie Retain Cycles zwischen Objekten und Closures mit Instruments.

Retain Cycles: Ursachen und Erkennung ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

Ein Referenzzyklus entsteht, wenn zwei oder mehr Objekte starke Referenzen aufeinander halten. Dadurch kann ARC niemals den Zählerstand null erreichen, was zu einem Speicherleck führt.

Einfacher Zyklus zwischen zwei Objekten

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

Zyklus zwischen Eltern- und Kindobjekt

```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 ```

Zyklus durch Closure-Capturing

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

Zyklus im Delegate-Pattern

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

Mit Instruments erkennen

Verwenden Sie Xcode Instruments → Leaks: 1. Führen Sie die App in Instruments aus 2. Klicken Sie auf das Instrument Leaks 3. Rote Markierungen weisen auf durchgesickerte Objekte hin 4. Untersuchen Sie die Details, um den Referenzgraphen zu sehen Alternativ können Sie `deinit { print(...) }` setzen und prüfen, ob es ausgeführt wird.

Mit dem Xcode Memory Graph erkennen

Öffnen Sie im Xcode-Debugger Debug > Memory Graph Debugger. Klicken Sie auf ein durchgesickertes Objekt, um seine Referenzkette anzuzeigen – der Zyklus ist im Graphen als geschlossene Schleife sichtbar.

Häufige Muster für Zyklen

• Ein Delegate speichert den Delegate als starke Referenz • Eine Closure erfasst `self` als starke Referenz • Bidirektionale starke Referenzen zwischen Eltern- und Kindobjekten • Ein NotificationCenter-Beobachter enthält eine Closure, die self erfasst • Das Ziel eines Timers ist `self` (stark)

Referenzzyklus bei Timern

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

NotificationCenter-Zyklus

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

Kurzer Test

Was ist ein Retain-Zyklus in ARC?

Zusammenfassung

Wichtige Erkenntnisse: • Retain-Zyklen: gegenseitige starke Referenzen → keines der Objekte wird deallokiert • Häufig bei: Delegates, Closures, bidirektionalen Parent-Child-Verknüpfungen • Erkennen mit Instruments Leaks oder dem Xcode Memory Graph Debugger • Beheben mit `weak`- oder `unowned`-Referenzen • Timer und NotificationCenter können ebenfalls Zyklen verursachen — mit `[weak self]` auflösen Als Nächstes: weak- und unowned-Referenzen.

Häufig gestellte Fragen

Ist die Lektion „Retain Cycles: Ursachen und Erkennung“ kostenlos?

Ja — der vollständige Text von „Retain Cycles: Ursachen und Erkennung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Retain Cycles: Ursachen und Erkennung“?

Erkennen Sie Retain Cycles zwischen Objekten und Closures mit Instruments. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Retain Cycles: Ursachen und Erkennung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Swift Academy