Actor isolation concept in Swift - Step-by-Step Execution

Concept Flow - Actor isolation concept

Start

↓

Create Actor Instance

↓

Call Actor Method

↓

Check if method is isolated

↓

Run inside

↓

actor's queue

↓

Update actor's state

↓

Return result

↓

End

This flow shows how Swift runs code inside an actor to keep its data safe, by isolating access to its state.

Execution Sample

Swift

actor Counter {
  var value = 0
  func increment() {
    value += 1
  }
}

let counter = Counter()
counter.increment()

This code creates an actor with a value and a method to increase it safely.

Execution Table

Step	Action	Inside Actor?	State Change	Output
1	Create actor instance 'counter'	No	value = 0	None
2	Call 'increment()' on 'counter'	No	None yet	None
3	Switch to actor's isolated context	Yes	None yet	None
4	Execute 'value += 1' inside actor	Yes	value = 1	None
5	Return from 'increment()'	Yes	value = 1	None
6	Back to caller context	No	value = 1	None
7	End	No	value = 1	None

💡 Execution stops after method completes and control returns to caller.

Variable Tracker

Variable	Start	After Step 1	After Step 4	Final
value	undefined	0	1	1

Key Moments - 2 Insights

Why do we switch to the actor's isolated context when calling 'increment()'?

Because the actor protects its data by running its methods inside a special queue, ensuring no other code changes 'value' at the same time (see execution_table step 3 and 4).

Can code outside the actor directly change 'value'?

No, only code inside the actor can change 'value'. Outside code must call actor methods, which run inside the actor's isolated context (see execution_table steps 2 and 4).

Visual Quiz - 3 Questions

Look at the execution table, at which step does 'value' change from 0 to 1?

A Step 2

B Step 3

C Step 4

D Step 6

💡 Hint

Check the 'State Change' column for when 'value' updates.

At which step does the code switch to run inside the actor's isolated context?

A Step 3

B Step 5

C Step 1

D Step 7

💡 Hint

Look for 'Inside Actor?' column showing 'Yes' for the first time.

If 'increment()' was called twice in a row, how would 'value' change after step 4 of the second call?

A value would be 1

B value would be 2

C value would be 0

D value would be unchanged

💡 Hint

Each call adds 1 to 'value' inside the actor (see variable_tracker and step 4).

Concept Snapshot

actor MyActor {
  var state
  func method() {
    // runs isolated
  }
}

- Actor methods run inside actor's queue
- Protects state from concurrent access
- Outside code calls methods serially
- Ensures safe, isolated state changes

Full Transcript

This visual trace shows how Swift's actor isolation works. First, an actor instance is created with initial state. When a method like 'increment()' is called, execution switches to the actor's isolated context to safely update its state. The variable 'value' changes only inside the actor, preventing outside code from modifying it directly. This isolation ensures safe concurrency by serializing access to the actor's data. The execution table tracks each step, showing when the state changes and when control returns to the caller. Key moments clarify why switching context is needed and how state is protected. The quiz tests understanding of when and how the state changes inside the actor.