Swift Academy · Lektion

Actors und Datenisolierung, nonisolated

Actors und Datenisolierung, nonisolated 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 Actors bereitstellen

Ein Actor schützt seinen veränderlichen Zustand. Zu jedem Zeitpunkt greift nur ein Task auf den isolierten Zustand zu; externe Aufrufer müssen seine Methoden mit await aufrufen.

Isolation = keine Data Races
Aufrufe zwischen Actors sind asynchron
nonisolated für reine oder statische Member

Grundlagen von Actors

Innerhalb des Actors erfolgt der Zugriff direkt. Von außerhalb müssen Sie sowohl Lese- als auch Schreibzugriffe auf isolierten Zustand mit await ausführen.

actor Counter {
    private var value: Int = 0   // isolated state

    func increment() { value += 1 }      // isolated method (async to outsiders)
    func get() -> Int { value }          // read isolated state
}

let c = Counter()
Task {
    await c.increment()
    print(await c.get())  // 1
}

Garantie der Serialisierung

Auch wenn mehrere Tasks gleichzeitig aufrufen, serialisiert der Actor den Zugriff auf seinen Zustand und verhindert dadurch Data Races.

actor BankAccount {
    private var balance: Int = 0
    func deposit(_ amount: Int) { balance += amount }
    func withdraw(_ amount: Int) -> Bool {
        if balance >= amount { balance -= amount; return true }
        return false
    }
    func current() -> Int { balance }
}

let acc = BankAccount()
Task {
    async let a = acc.deposit(50)
    async let b = acc.withdraw(20)
    _ = await (a, b)                 // operations are serialized inside the actor
    print(await acc.current())       // deterministic balance
}

nonisolated-APIs

Kennzeichnen Sie reine oder statische Member mit nonisolated, damit Aufrufer kein await benötigen. Auf isolierten Zustand dürfen diese Member nicht zugreifen.

actor Clock {
    private var ticks: Int = 0
    func tick() { ticks += 1 }
    func read() -> Int { ticks }

    // Nonisolated: safe without awaiting (pure computation / constant)
    nonisolated static let format = "HH:mm:ss"

    nonisolated func describeFormat() -> String {
        // Cannot touch isolated state here; this is pure
        return "Format: " + Self.format
    }
}

let cl = Clock()
Task {
    await cl.tick()
    print(await cl.read())           // 1
    // Nonisolated members don't require await:
    print(Clock.format)              // "HH:mm:ss"
    print(cl.describeFormat())       // sync call
}

Reentrancy verstehen

Actors können reentrant sein: Nach einem await innerhalb einer Actor-Methode können andere Nachrichten ausgeführt werden. Halten Sie Invarianten über await-Punkte hinweg gültig.

actor Logger {
    private var lines: [String] = []
    func log(_ s: String) async {
        lines.append(s)
        // Simulate an await point; actor may process other messages here (reentrant)
        try? await Task.sleep(nanoseconds: 10_000_000)
        lines.append("done")
    }
    func snapshot() -> [String] { lines }
}

let logger = Logger()
Task {
    async let a = logger.log("A")
    async let b = logger.log("B")
    _ = await (a, b)
    print(await logger.snapshot())   // order shows possible interleaving
}

Bewährte Vorgehensweisen

Richtlinien:

Stellen Sie kleine asynchrone Methoden bereit und vermeiden Sie lange kritische Abschnitte.
Verwenden Sie nonisolated für Konstanten und reine Hilfsfunktionen.
Speichern Sie keinen gemeinsam genutzten veränderlichen Zustand, der nicht Sendable ist, außerhalb von Actors (als Nächstes lernen Sie Sendable kennen).

Anforderung an Actor-Isolation

Kurztest: Wie lesen oder schreiben Sie von außerhalb auf den Zustand eines Actors?

Zusammenfassung

Zusammenfassung: Actors isolieren veränderlichen Zustand; für den externen Zugriff ist await erforderlich. Verwenden Sie nonisolated für reine oder statische Member und entwerfen Sie kurze asynchrone Methoden, damit Reentrancy sicher bleibt.

Häufig gestellte Fragen

Ist die Lektion „Actors und Datenisolierung, nonisolated“ kostenlos?

Ja — der vollständige Text von „Actors und Datenisolierung, nonisolated“ 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 „Actors und Datenisolierung, nonisolated“?

Lernen Sie die Actor-Isolierung kennen: Der Zustand wird hinter einem actor geschützt, der Zugriff von einem anderen Actor erfordert await , und nonisolated -Member umgehen die Isolierung, wenn sie r… 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 „Actors und Datenisolierung, nonisolated“?

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

TaskGroup für Parallelität
Actors und Datenisolierung, nonisolated
Sendable und Prüfung der Thread-Sicherheit

← Zurück zu Swift Academy