0Pricing
Swift Academy · Lektion

Retain Cycles erkennen und mit weak/unowned aufbrechen

Erkennen Sie Retain Cycles zwischen Objekten und Closures und brechen Sie sie sicher mit weak - und unowned -Referenzen auf.

Retain Cycles erkennen und mit weak/unowned aufbrechen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. 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 3 Lektionen.

Was ist ein Retain-Zyklus?

Ein Retain-Zyklus entsteht, wenn Objekte oder Closures sich gegenseitig über strong-Referenzen festhalten, sodass ARC nie null erreicht. Brechen Sie Zyklen mit weak oder unowned.

Zyklus zwischen Objekten

Zwei strong-Referenzen in entgegengesetzte Richtungen erzeugen ein Leak: Keines der beiden Objekte kann auf null fallen.

final class Owner {
    var gadget: Gadget?
    deinit { print("Owner deinit") }
}
final class Gadget {
    var owner: Owner?
    deinit { print("Gadget deinit") }
}
// Strong ⇄ strong (cycle)
var o: Owner? = Owner()
var g: Gadget? = Gadget()
o!.gadget = g
g!.owner = o
o = nil      // no deinit
g = nil      // still no deinit (leak)

Mit weak auflösen

Machen Sie eine Seite weak (häufig die Rückreferenz, etwa delegate/owner), damit ARC beide Objekte freigeben kann.

final class Owner2 {
    var gadget: Gadget2?
    deinit { print("Owner2 deinit") }
}
final class Gadget2 {
    weak var owner: Owner2?   // weak breaks cycle; becomes nil automatically
    deinit { print("Gadget2 deinit") }
}
var o2: Owner2? = Owner2()
var g2: Gadget2? = Gadget2()
o2!.gadget = g2
g2!.owner = o2
o2 = nil     // Owner2 deinit
g2 = nil     // Gadget2 deinit

Closure-Zyklus (starkes self)

Closures erfassen Variablen standardmäßig über strong-Referenzen. Wenn das Objekt außerdem das Closure besitzt, entsteht dadurch ein Zyklus.

final class TimerClient {
    var tick: (() -> Void)?
    deinit { print("TimerClient deinit") }
    func start() {
        // BAD: closure strongly captures self; self keeps tick strongly
        tick = {
            print("tick from", self) // strong capture of self
        }
    }
}
var c: TimerClient? = TimerClient()
c!.start()
c = nil   // no deinit — closure holds self strongly

Mit Capture-Listen auflösen

Verwenden Sie [weak self] (optional) für eine sichere Bereinigung; verwenden Sie [unowned self] nur, wenn garantiert ist, dass self bei der Ausführung des Closures noch lebt.

final class TimerClient2 {
    var tick: (() -> Void)?
    deinit { print("TimerClient2 deinit") }
    func start() {
        // Use [weak self] when self can go away before tick runs
        tick = { [weak self] in
            guard let self = self else { return } // safe unwrap
            print("tick from", self)
        }
        // Alternative when lifetime is guaranteed: [unowned self]
        // tick = { [unowned self] in print("tick from", self) }
    }
}
var c2: TimerClient2? = TimerClient2()
c2!.start()
c2 = nil   // deinit now prints — no cycle

Checkliste

Checkliste:

  • Gibt es Referenzen in beide Richtungen? Machen Sie eine Seite weak (z. B. delegate).
  • Werden Closures in einem Typ gespeichert? Erfassen Sie [weak self] und lösen Sie die Referenz sicher auf.
  • Verwenden Sie [unowned self] nur bei garantierter Lebensdauer; andernfalls kann das Programm abstürzen.

weak vs. unowned in Closures

Kurztest: Welche Capture-Liste ist sicherer, wenn das Objekt freigegeben werden kann?

Zusammenfassung

Zusammenfassung: Erkennen Sie Zyklen in Objekten und Closures. Brechen Sie sie passend mit weak oder unowned; verwenden Sie im Zweifel bevorzugt weak.

Häufig gestellte Fragen

Ist die Lektion „Retain Cycles erkennen und mit weak/unowned aufbrechen“ kostenlos?

Ja — der vollständige Text von „Retain Cycles erkennen und mit weak/unowned aufbrechen“ 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 3 Lektionen.

Was lerne ich in „Retain Cycles erkennen und mit weak/unowned aufbrechen“?

Erkennen Sie Retain Cycles zwischen Objekten und Closures und brechen Sie sie sicher mit weak - und unowned -Referenzen auf. 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 3.

Wie lange dauert die Lektion „Retain Cycles erkennen und mit weak/unowned aufbrechen“?

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

  1. Grundlagen von ARC: strong / weak / unowned
  2. Retain Cycles erkennen und mit weak/unowned aufbrechen
  3. Werttypen zur Verringerung gemeinsamer Nutzung
← Zurück zu Swift Academy