Nonisolated methods in Swift - Step-by-Step Execution

Concept Flow - Nonisolated methods

Define actor with isolated and nonisolated methods

↓

Call nonisolated method

↓

Execute method without actor isolation

↓

Return result immediately

↓

Call isolated method

↓

Execute method with actor isolation

↓

Await if needed, then return result

Nonisolated methods run without actor isolation, allowing immediate synchronous calls, unlike isolated methods that require awaiting.

Execution Sample

Swift

actor MyActor {
  nonisolated func greet() -> String {
    "Hello from nonisolated"
  }
  func isolatedGreet() async -> String {
    "Hello from isolated"
  }
}

let actor = MyActor()
print(actor.greet())

Defines an actor with a nonisolated method that can be called synchronously without awaiting.

Execution Table

Step	Action	Method Called	Isolation	Result	Notes
1	Create actor instance	-	-	MyActor instance	Actor instance created
2	Call greet()	greet	nonisolated	"Hello from nonisolated"	Runs immediately, no await needed
3	Print result	-	-	Hello from nonisolated	Output to console
4	Call isolatedGreet()	isolatedGreet	isolated	async String	Requires await, not shown here
5	Await isolatedGreet()	isolatedGreet	isolated	"Hello from isolated"	Runs with actor isolation
6	Print isolated result	-	-	Hello from isolated	Output after await

💡 Nonisolated method returns immediately; isolated method requires awaiting for safe actor access.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 4	Final
actor	nil	MyActor instance	MyActor instance	MyActor instance	MyActor instance
greet() result	nil	nil	"Hello from nonisolated"	"Hello from nonisolated"	"Hello from nonisolated"
isolatedGreet() result	nil	nil	nil	async String (pending)	"Hello from isolated"

Key Moments - 3 Insights

Why can we call the nonisolated method without await?

Because nonisolated methods run outside actor isolation, they behave like normal synchronous methods, as shown in execution_table step 2.

What happens if we call an isolated method without await?

The code will not compile or will require async handling because isolated methods enforce actor isolation, as seen in execution_table step 4.

Does nonisolated mean the method is unsafe?

No, nonisolated means the method does not access actor-isolated state and is safe to run synchronously, as implied by the immediate return in step 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result of calling greet() at step 2?

A "Hello from nonisolated"

B "Hello from isolated"

C async String

D No result, must await

💡 Hint

Check the 'Result' column at step 2 in execution_table.

At which step does the isolated method require awaiting?

A Step 2

B Step 3

C Step 4

D Step 1

💡 Hint

Look at the 'Isolation' and 'Notes' columns for step 4 in execution_table.

If greet() accessed actor-isolated state, what would change in the execution?

A It would still run synchronously without await

B It would require async and await like isolatedGreet()

C It would return a different string immediately

D It would cause a runtime error

💡 Hint

Nonisolated methods cannot access isolated state; see key_moments about safety.

Concept Snapshot

Nonisolated methods in Swift actors:
- Declared with 'nonisolated' keyword
- Run outside actor isolation
- Can be called synchronously without await
- Must not access actor-isolated state
- Isolated methods require async/await
- Use nonisolated for safe, immediate calls

Full Transcript

This visual trace shows how nonisolated methods in Swift actors work. First, an actor instance is created. Then, calling the nonisolated method greet() runs immediately without needing await, returning a string right away. In contrast, calling the isolated method isolatedGreet() requires awaiting because it runs with actor isolation to protect state. Variables track the actor instance and method results step-by-step. Key moments clarify why nonisolated methods can run synchronously and the safety rules. The quiz tests understanding of method calls, awaiting, and actor isolation. The snapshot summarizes the main points about nonisolated methods.