Why actors prevent data races in Swift - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Understanding actor isolation in Swift

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

Swift

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

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

A Runtime error due to data race

B 0

C Compilation error due to missing await

D 1

💡 Hint

Remember that actors serialize access to their mutable state.

The actor ensures that only one task accesses or modifies its state at a time. The increment() method increases value by 1, and getValue() returns it. Both are awaited, so the printed value is 1.

🧠 Conceptual

intermediate

Why do actors prevent data races?

Which statement best explains why Swift actors prevent data races?

A Actors serialize access to their mutable state, ensuring only one task can modify it at a time.

B Actors allow multiple threads to write to the same variable simultaneously.

C Actors disable concurrency to avoid any parallel execution.

D Actors copy all data before modifying it, so no shared state exists.

💡 Hint

Think about how actors control access to their internal data.

Actors prevent data races by serializing access to their mutable state, so only one task can read or write at a time, avoiding simultaneous conflicting accesses.

🔧 Debug

advanced

Identify the data race in this Swift code

What error or problem will occur when running this code without using an actor?

Swift

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

let counter = Counter()
DispatchQueue.concurrentPerform(iterations: 1000) { _ in
    counter.increment()
}
print(counter.value)

A The printed value will always be 1000

B The printed value may be less than 1000 due to a data race

C Compilation error because DispatchQueue.concurrentPerform is not allowed

D Runtime crash due to actor isolation violation

💡 Hint

Consider what happens when multiple threads modify the same variable without synchronization.

Without synchronization, multiple threads can modify value simultaneously, causing lost updates and a final value less than 1000.

📝 Syntax

advanced

Which code snippet correctly uses an actor to prevent data races?

Choose the code that correctly defines and uses an actor to safely increment a counter.

A

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

let counter = Counter()
await counter.increment()

B

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

let counter = Counter()
counter.increment()

C

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

let counter = Counter()
await counter.increment()

D

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

let counter = Counter()
counter.increment()

💡 Hint

Remember that actor methods that modify state are asynchronous and must be awaited.

Option A correctly defines an actor with an async method and calls it with await. Option A misses async/await, C uses a class not an actor, and D calls async method without await.

🚀 Application

expert

Predict the final value with concurrent actor calls

Given this Swift code, what is the final printed value of the counter after all tasks complete?

Swift

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

let counter = Counter()

Task {
    await withTaskGroup(of: Void.self) { group in
        for _ in 1...10 {
            group.addTask {
                await counter.increment()
            }
        }
    }
    let finalValue = await counter.getValue()
    print(finalValue)
}

A 0

B 1

C 10

D Runtime error due to data race

💡 Hint

Actors serialize access even if tasks run concurrently.

Even though increments run concurrently, the actor serializes access to value, so all increments apply correctly, resulting in 10.