PricingLoginStart free
Swift Academy · Lesson

Actors: Protecting Shared Mutable State

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

Lesson 4 of 412 steps

Actors: Protecting Shared Mutable State is a free Swift Academy lesson on CoddyKit. This is lesson 4 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, and your progress syncs across the web and the CoddyKit app. The Swift Academy course includes 4 lessons in total.

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`?
Answer it in the interactive lesson

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.
Free to start

Learn Swift with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses
122
Lessons
409
Start learning freeView the full course

Frequently Asked Questions

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

Yes — any 3 lessons of the Swift Academy learning path, including “Actors: Protecting Shared Mutable State”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The Swift Academy course includes 4 lessons in total.

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, so you can start here or from the beginning and move at your own pace. This is lesson 4 of 4.

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