PricingLoginStart free
Swift Academy · Lektion

Actors: Gemeinsam genutzten veränderlichen Zustand schützen

Verwenden Sie actor, um Zugriffe zu serialisieren und Datenrennen bereits zur Compile-Zeit zu verhindern.

Lektion 4 von 412 Schritte

Actors: Gemeinsam genutzten veränderlichen Zustand schützen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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

Swift Actors schützen gemeinsam veränderlichen Zustand mithilfe von *Actor-Isolation* vor nebenläufigem Zugriff. Sie ermöglichen sichere Nebenläufigkeit ohne manuelle Sperren.

Einen Actor definieren

```swift actor Counter { var count = 0 func increment() { count += 1 } func value() -> Int { count } } ```

Auf den Zustand eines Actors zugreifen

```swift let counter = Counter() await counter.increment() // await required for external access let v = await counter.value() ``` Alle Aufrufe zwischen Actors sind asynchron – sie warten, bis der Actor an der Reihe ist.

Datenisolation

```swift actor BankAccount { private var balance: Double = 0 func deposit(_ amount: Double) { balance += amount } func withdraw(_ amount: Double) throws { guard amount <= balance else { throw BankError.insufficient } balance -= amount } } ```

nonisolated

```swift actor Config { nonisolated let appName: String = "CoddyKit" // safe to access without await var settings: [String:String] = [:] } let name = Config().appName // no await needed ```

@MainActor

```swift @MainActor class ViewController { var label = UILabel() func updateText(_ text: String) { label.text = text // guaranteed on main thread } } ``` `@MainActor` ist ein spezieller Actor, der im Hauptthread ausgeführt wird.

Sendable-Anforderung

Typen, die Actor-Grenzen überschreiten, müssen `Sendable` entsprechen: ```swift struct Message: Sendable { var text: String; var timestamp: Date } await actor.receive(message) // safe — Message is Sendable ```

Actor vs. Class

| Merkmal | Actor | Class | |---|---|---| | Nebenläufigkeitssicher | ✓ | ✗ | | Referenztyp | ✓ | ✓ | | Vererbung | ✗ | ✓ | | Asynchroner Zugriff | ✓ | — |

Actors können keinen Deadlock verursachen

Anders als Sperren können Actors keinen Deadlock verursachen – sie können jedoch *Actor-Reentrancy* auslösen, wenn ein Actor auf einen anderen wartet und dazwischen ein zweiter Aufruf eingeht.

Globale Actors

```swift @globalActor struct DatabaseActor { static let shared = Actor() actor Actor {} } @DatabaseActor func save() { ... } ```

Kurztest

Warum muss beim externen Zugriff auf Actor-Eigenschaften `await` verwendet werden?
Beantworte es in der interaktiven Lektion

Zusammenfassung

Wichtige Erkenntnisse: • Actors schützen veränderlichen Zustand – jeweils nur ein Task wird ausgeführt • Externer Zugriff erfordert `await` • `nonisolated` für sichere nicht isolierte Member • `@MainActor` – wird im Hauptthread ausgeführt; für UI verwenden • Typen, die Actor-Grenzen überschreiten, müssen `Sendable` sein Kurs abgeschlossen! Als Nächstes: Advanced Generics.
Kostenlos starten

Lerne Swift mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
122
Lektionen
409
Kostenlos lernenDen vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Actors: Gemeinsam genutzten veränderlichen Zustand schützen“ kostenlos?

Ja — der vollständige Text von „Actors: Gemeinsam genutzten veränderlichen Zustand schützen“ 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 „Actors: Gemeinsam genutzten veränderlichen Zustand schützen“?

Verwenden Sie actor, um Zugriffe zu serialisieren und Datenrennen bereits zur Compile-Zeit zu verhindern. 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 4 von 4.

Wie lange dauert die Lektion „Actors: Gemeinsam genutzten veränderlichen Zustand schützen“?

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. async/await-Syntax und Aufruf asynchroner Funktionen
  2. Task und Task-Abbruch
  3. async let und nebenläufige Kind-Tasks
  4. Actors: Gemeinsam genutzten veränderlichen Zustand schützen
← Zurück zu Swift Academy