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.

Practice

1. What is the main purpose of marking a method as nonisolated in a Swift actor?

easy

A. To allow the method to run outside the actor's isolation without needing await

B. To make the method private to the actor

C. To force the method to always run asynchronously

D. To prevent the method from accessing any properties

Solution

1. Step 1: Understand actor isolation

   Actors protect their data by isolating it, so methods usually run inside this isolation.

2. Step 2: Role of nonisolated

   Marking a method nonisolated means it runs outside this isolation and can be called without await.

3. Final Answer:

   To allow the method to run outside the actor's isolation without needing await -> Option A

4. Quick Check:

   Nonisolated method = runs outside isolation without await [OK]

Hint: Nonisolated means no await needed to call method [OK]

Common Mistakes:

• Thinking nonisolated methods are private
• Assuming nonisolated methods must be async
• Believing nonisolated methods cannot access any properties

2. Which of the following is the correct way to declare a nonisolated method inside a Swift actor?

easy

A. func nonisolated greet() { print("Hello") }

B. nonisolated func greet() { print("Hello") }

C. func greet() nonisolated { print("Hello") }

D. func greet() async nonisolated { print("Hello") }

Solution

1. Step 1: Recall correct syntax for nonisolated

   The nonisolated keyword comes before func in the method declaration.

2. Step 2: Check each option

   nonisolated func greet() { print("Hello") } correctly places nonisolated before func. Others place it incorrectly or add unnecessary keywords.

3. Final Answer:

   nonisolated func greet() { print("Hello") } -> Option B

4. Quick Check:

   Keyword nonisolated before func = correct syntax [OK]

Hint: Put nonisolated before func keyword [OK]

Common Mistakes:

• Placing nonisolated after func
• Adding async unnecessarily
• Using nonisolated as a function modifier

3. What will be the output of the following Swift code?

actor Counter {
    var count = 0
    nonisolated func printHello() {
        print("Hello")
    }
    func increment() {
        count += 1
    }
}

let counter = Counter()
counter.printHello()
// counter.increment() // requires await

medium

A. Compile error because printHello is nonisolated

B. Hello\n1

C. Hello

D. Runtime error because increment is not awaited

Solution

1. Step 1: Understand nonisolated method call

   The method printHello() is marked nonisolated, so it can be called directly without await.

2. Step 2: Analyze output

   Calling counter.printHello() prints "Hello". The increment method is commented out, so no other output.

3. Final Answer:

   Hello -> Option C

4. Quick Check:

   Nonisolated method prints Hello directly [OK]

Hint: Nonisolated methods run without await and print output [OK]

Common Mistakes:

• Expecting increment output without await
• Thinking nonisolated causes compile error
• Confusing runtime error with compile error

4. Consider this Swift actor code snippet:

actor Logger {
    var logs = [String]()
    nonisolated func printLog(_ message: String) {
        print(message)
    }
    func addLog(_ message: String) {
        logs.append(message)
    }
}

let logger = Logger()
logger.printLog("Start")
logger.addLog("Start")

What is the main issue with this code?

medium

A. addLog method must be marked nonisolated

B. Nonisolated method printLog cannot access actor's logs array

C. Nonisolated method printLog causes data race on logs

D. Cannot call addLog without await, causing a compile error

Solution

1. Step 1: Check method calls

   The addLog method is isolated and must be called with await outside the actor.

2. Step 2: Identify error

   Calling logger.addLog("Start") without await causes a compile error.

3. Final Answer:

   Cannot call addLog without await, causing a compile error -> Option D

4. Quick Check:

   Isolated method call requires await [OK]

Hint: Isolated methods need await; nonisolated do not [OK]

Common Mistakes:

• Thinking nonisolated can access isolated properties
• Assuming addLog can be called without await
• Marking all methods nonisolated incorrectly

5. You want to add a nonisolated method to a Swift actor that returns a constant string without accessing any actor-isolated data. Which of the following implementations is correct and safe?

hard

A. nonisolated func status() -> String { return "Ready" }

B. nonisolated func status() -> String { return logs.first ?? "Ready" }

C. func status() async -> String { return "Ready" }

D. func status() -> String { return "Ready" }

Solution

1. Step 1: Identify safe nonisolated method

   A nonisolated method must not access actor-isolated data like logs.

2. Step 2: Evaluate options

   nonisolated func status() -> String { return "Ready" } returns a constant string without accessing isolated data, so it's safe and correct.

3. Final Answer:

   nonisolated func status() -> String { return "Ready" } -> Option A

4. Quick Check:

   Nonisolated method returns constant, no isolated data access [OK]

Hint: Nonisolated methods must avoid actor-isolated data [OK]

Common Mistakes:

• Accessing isolated properties inside nonisolated methods
• Making nonisolated methods async unnecessarily
• Ignoring actor isolation rules