Actors vs locks decision in Swift - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of concurrent access with actor

What will be the output of this Swift code using an actor to protect shared state?

Swift

actor Counter {
    var value = 0
    func increment() {
        value += 1
    }
    func getValue() -> Int {
        return value
    }
}

let counter = Counter()

Task {
    await counter.increment()
}

Task {
    await counter.increment()
}

Task {
    let val = await counter.getValue()
    print(val)
}

// Wait a moment to let tasks finish
Thread.sleep(forTimeInterval: 0.1)

A 2

B 0

C 1

D Compilation error

💡 Hint

Actors serialize access to their internal state, so increments are safe.

The actor ensures that increments happen one at a time, so after two increments, the value is 2.

❓ Predict Output

intermediate

Output of concurrent access with lock

What will be the output of this Swift code using a lock to protect shared state?

Swift

class Counter {
    private var value = 0
    private let lock = NSLock()
    func increment() {
        lock.lock()
        value += 1
        lock.unlock()
    }
    func getValue() -> Int {
        lock.lock()
        let val = value
        lock.unlock()
        return val
    }
}

let counter = Counter()

DispatchQueue.global().async {
    counter.increment()
}

DispatchQueue.global().async {
    counter.increment()
}

DispatchQueue.global().async {
    print(counter.getValue())
}

// Wait a moment to let async tasks finish
Thread.sleep(forTimeInterval: 0.1)

A 0

B 2

C 1

D Runtime error

💡 Hint

The lock ensures only one thread changes the value at a time.

The NSLock serializes access to the value, so both increments happen safely, resulting in 2.

🧠 Conceptual

advanced

Choosing between actors and locks

Which of the following is the best reason to choose actors over locks in Swift concurrency?

A Actors allow multiple threads to write to the same variable simultaneously for better performance.

B Actors are only useful for UI updates and not for data protection.

C Actors automatically serialize access to their state, reducing risk of deadlocks and race conditions.

D Actors require manual lock management, giving more control over concurrency.

💡 Hint

Think about safety and ease of use in concurrency.

Actors provide automatic serialization of access, making code safer and easier to write compared to manual locks.

❓ Predict Output

advanced

Output difference between actor and lock with async delay

What is the output of this Swift code comparing actor and lock with async delay?

Swift

actor AsyncCounter {
    var value = 0
    func increment() async {
        let current = value
        try? await Task.sleep(nanoseconds: 100_000_000) // 0.1 sec
        value = current + 1
    }
    func getValue() -> Int {
        return value
    }
}

class LockCounter {
    private var value = 0
    private let lock = NSLock()
    func increment() {
        lock.lock()
        let current = value
        Thread.sleep(forTimeInterval: 0.1)
        value = current + 1
        lock.unlock()
    }
    func getValue() -> Int {
        lock.lock()
        let val = value
        lock.unlock()
        return val
    }
}

let actorCounter = AsyncCounter()
let lockCounter = LockCounter()

Task {
    await actorCounter.increment()
}
Task {
    await actorCounter.increment()
}

DispatchQueue.global().async {
    lockCounter.increment()
}
DispatchQueue.global().async {
    lockCounter.increment()
}

// Wait for increments
Thread.sleep(forTimeInterval: 0.3)

Task {
    print("ActorCounter: \(await actorCounter.getValue())")
    print("LockCounter: \(lockCounter.getValue())")
}

A ActorCounter: 2\nLockCounter: 2

B ActorCounter: 1\nLockCounter: 2

C ActorCounter: 2\nLockCounter: 1

D ActorCounter: 1\nLockCounter: 1

💡 Hint

Actors serialize async calls, locks serialize threads.

Both actor and lock serialize increments, so both counters end at 2.

🧠 Conceptual

expert

When to prefer locks over actors

In which scenario is using locks preferred over actors in Swift concurrency?

A When you want to isolate state in a single-threaded context automatically.

B When you want automatic serialization of state without manual lock management.

C When you want to avoid any blocking and use only asynchronous code.

D When you need fine-grained control over locking multiple resources simultaneously to avoid deadlocks.

💡 Hint

Think about complex locking scenarios involving multiple resources.

Locks allow manual control over multiple locks and can be used to avoid deadlocks with careful design, which actors do not support.