Actor isolation concept in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift actor code?

Consider this Swift code using an actor. What will be printed when printCounter() is called?

Swift

actor Counter {
    var value = 0
    func increment() {
        value += 1
    }
    func printCounter() {
        print("Counter value: \(value)")
    }
}

let counter = Counter()
Task {
    await counter.increment()
    await counter.printCounter()
}

A Runtime error due to actor isolation violation

B Counter value: 1

C Compilation error due to missing await

D Counter value: 0

💡 Hint

Remember that actor methods must be called with await outside the actor.

The increment() method increases value by 1. Both methods are called with await inside a Task, so the actor isolation rules are respected. The printed value is 1.

🧠 Conceptual

intermediate

Which statement best describes actor isolation in Swift?

Choose the statement that correctly explains actor isolation.

A Actors isolate their mutable state to ensure only one task accesses it at a time.

B Actors allow shared mutable state without any synchronization.

C Actors require all methods to be synchronous to avoid data races.

D Actors automatically copy their state when accessed from multiple tasks.

💡 Hint

Think about how actors protect their data from concurrent access.

Actors isolate their mutable state so that only one task can access it at a time, preventing data races. This is done using asynchronous calls and await.

🔧 Debug

advanced

What error does this Swift code produce?

Examine this code snippet. What error will the compiler report?

Swift

actor BankAccount {
    var balance = 1000
    func deposit(amount: Int) {
        balance += amount
    }
}

let account = BankAccount()
account.deposit(amount: 500)

A Error: Call to actor-isolated method 'deposit' in a synchronous context requires 'await'

B Error: Cannot mutate 'balance' because it is a constant

C No error, code runs successfully

D Error: Missing 'async' keyword in function declaration

💡 Hint

Think about how actor methods must be called from outside the actor.

The method deposit is actor-isolated and must be called with await from outside the actor. Calling it synchronously causes a compiler error.

📝 Syntax

advanced

Which option correctly declares an actor with an isolated mutable property?

Choose the correct Swift code that declares an actor with a mutable property count initialized to 0.

A

actor Counter {
    let count = 0
}

B

actor Counter {
    var count: Int
    init() { count = 0 }
}

C

actor Counter {
    static var count = 0
}

D

actor Counter {
    var count: Int = 0
}

💡 Hint

Remember that mutable properties inside actors are declared with var.

Option D correctly declares a mutable property count initialized to 0. Option D uses let which is immutable. Option D declares a static property, which is shared and not isolated. Option D is valid syntax but unnecessarily verbose compared to A.

🚀 Application

expert

How many times will the actor's method be executed concurrently?

Given this Swift code, how many concurrent executions of increment() can happen inside the actor?

Swift

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

let counter = Counter()
Task {
    await withTaskGroup(of: Void.self) { group in
        for _ in 1...5 {
            group.addTask {
                await counter.increment()
            }
        }
    }
}

A No executions happen because increment is not async

B 5 concurrent executions happen inside the actor

C Only 1 execution happens at a time due to actor isolation

D Executions run concurrently but cause a data race

💡 Hint

Think about how actor isolation serializes access to its mutable state.

Actors serialize access to their isolated state, so even though 5 tasks call increment() concurrently, only one executes at a time inside the actor, preventing data races.