Sendable protocol for thread safety in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code using Sendable?

Consider this Swift code snippet using the Sendable protocol. What will be printed?

Swift

import Foundation

struct Counter: Sendable {
    var value: Int
    mutating func increment() {
        value += 1
    }
}

func updateCounter(counter: inout Counter) {
    counter.increment()
}

var myCounter = Counter(value: 0)
updateCounter(counter: &myCounter)
print(myCounter.value)

A 1

B 0

C Compilation error due to Sendable conformance

D Runtime error due to thread safety violation

💡 Hint

Think about what Sendable means for value types and how mutation affects the value.

The struct Counter conforms to Sendable, meaning it can be safely used across concurrency domains. The increment() method increases value by 1. After calling updateCounter, myCounter.value becomes 1.

🧠 Conceptual

intermediate

Which type automatically conforms to Sendable in Swift?

Which of the following Swift types automatically conform to the Sendable protocol without extra code?

A Enums with associated reference types

B Closures capturing mutable state

C Classes with mutable properties

D Structs with only stored properties that are Sendable

💡 Hint

Think about value types and their stored properties.

Structs whose stored properties all conform to Sendable automatically conform to Sendable. Classes and closures capturing mutable state do not automatically conform.

🔧 Debug

advanced

What error does this code raise related to Sendable?

Examine this Swift code snippet. What error will the compiler produce?

Swift

import Foundation

class DataHolder {
    var data: String
    init(data: String) {
        self.data = data
    }
}

struct Container: Sendable {
    var holder: DataHolder
}

A No error, code compiles successfully

B Runtime error due to data race

C Type 'DataHolder' does not conform to 'Sendable'

D Missing initializer error

💡 Hint

Check if classes conform to Sendable automatically.

Classes do not automatically conform to Sendable. Since Container has a stored property of class type DataHolder which is not Sendable, the compiler raises a conformance error.

📝 Syntax

advanced

Which option correctly declares a Sendable class in Swift?

Which of the following Swift class declarations correctly conforms to Sendable?

A class UnsafeClass: Sendable {}

B final class SafeClass: Sendable {}

C final class SafeClass: Sendable { var value: Int }

D class SafeClass: Sendable { let value: Int }

💡 Hint

Consider what makes a class conform to Sendable safely.

Only final classes without mutable shared state can conform to Sendable safely. Option B declares a final class with no stored properties, so it conforms. Other options either lack final or have mutable properties without synchronization.

🚀 Application

expert

How many items are in the dictionary after this concurrent Sendable code runs?

Given this Swift code using concurrency and Sendable, how many items will the dictionary contain after execution?

Swift

import Foundation

@Sendable
func addItem(to dict: inout [Int: String], key: Int, value: String) {
    dict[key] = value
}

var sharedDict = [Int: String]()

let queue = DispatchQueue(label: "concurrent", attributes: .concurrent)

for i in 0..<5 {
    queue.async(flags: .barrier) {
        addItem(to: &sharedDict, key: i, value: "Item \(i)")
    }
}

queue.sync(flags: .barrier) {}

print(sharedDict.count)

A 5

B 0

C Less than 5 due to race conditions

D Compilation error due to Sendable misuse

💡 Hint

Consider how the barrier flag affects concurrent writes.

The barrier flag ensures that each write to sharedDict happens exclusively, preventing race conditions. Therefore, all 5 items are added, and the dictionary count is 5.