0Pricing
Swift Academy · Lesson

Actors: Protecting Shared Mutable State

Using actor to serialize access and prevent data races at compile time.

Actors: Protecting Shared Mutable State is a free Swift Academy lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Welcome

Swift Actors protect shared mutable state from concurrent access using *actor isolation*. They provide safe concurrency without manual locks.

Defining an Actor

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

Accessing Actor State

```swift let counter = Counter() await counter.increment() // await required for external access let v = await counter.value() ``` All cross-actor calls are async — they wait for the actor's turn.

Data Isolation

```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` is a special actor that runs on the main thread.

Sendable Requirement

Types passed across actor boundaries must conform to `Sendable`: ```swift struct Message: Sendable { var text: String; var timestamp: Date } await actor.receive(message) // safe — Message is Sendable ```

Actor vs Class

| Feature | Actor | Class | |---|---|---| | Concurrency safe | ✓ | ✗ | | Reference type | ✓ | ✓ | | Inheritance | ✗ | ✓ | | async access | ✓ | — |

Actors Cannot Deadlock

Unlike locks, actors cannot deadlock — but they can cause *actor reentrancy* when an actor awaits another actor and a second call arrives in between.

Global Actors

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

Quick Check

Why must external access to actor properties use `await`?

Recap

Key takeaways: • Actors protect mutable state — one task runs at a time • External access requires `await` • `nonisolated` for safe non-isolated members • `@MainActor` — runs on main thread; use for UI • Types crossing actor boundaries must be `Sendable` Course complete! Next: Advanced Generics.

Frequently asked questions

Is the “Actors: Protecting Shared Mutable State” lesson free?

Yes — the full text of “Actors: Protecting Shared Mutable State” is free to read here on the web, and the Swift Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Swift Academy course, upgrade to CoddyKit PRO.

What will I learn in “Actors: Protecting Shared Mutable State”?

Using actor to serialize access and prevent data races at compile time. You practise Swift Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Swift Academy?

No prior experience is required. Swift Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Actors: Protecting Shared Mutable State” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Swift Academy lesson?

Yes. Every Swift Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. async/await Syntax and Calling Async Functions
  2. Task and Task Cancellation
  3. async let and Concurrent Child Tasks
  4. Actors: Protecting Shared Mutable State
← Back to Swift Academy