Sendable e controllo della thread safety

Che cos'è Sendable?

I tipi valore sono semplici

// Value types with value-only stored properties are Sendable.
// They are safe to transfer across tasks.
struct Point: Sendable { let x: Int; let y: Int }

func shift(_ p: Point) -> Point { Point(x: p.x + 1, y: p.y + 1) }

// Use in parallel tasks
Task {
    let p = Point(x: 1, y: 2)
    async let a = shift(p)
    async let b = shift(p)
    let (p1, p2) = await (a, b)
    print(p1, p2) // Point(x: 2, y: 3) Point(x: 2, y: 3)
}

Classi: utilizzi gli actor

// Reference types (class) are not Sendable by default.
// Prefer actors to guard mutable state.
actor SafeCounter {
    private var value = 0
    func inc() { value += 1 }
    func read() -> Int { value }
}

let counter = SafeCounter()
Task {
    async let t1 = counter.inc()
    async let t2 = counter.inc()
    _ = await (t1, t2)
    print(await counter.read()) // 2
}

// (Alternative) A plain class would need locks + @unchecked Sendable; see later.

Closure @Sendable

// Some APIs require closures to be @Sendable so captured values are safe.
func doTwice(_ f: @Sendable () -> Int) -> Int { f() + f() }

let base = 10
// Capturing an immutable value (let) is fine for @Sendable closures.
let result = doTwice { base + 1 }
print(result) // 22

// Detached tasks also use @Sendable under the hood:
let t = Task.detached { () -> Int in
    // Do not capture non-Sendable mutable state here.
    return 5 * 5
}
Task { print(await t.value) }

@unchecked Sendable (avanzato)

import Foundation

// Only when you KNOW it is safe: wrap with a lock and mark @unchecked Sendable.
final class Box<T>: @unchecked Sendable {
    private var value: T
    private let lock = NSLock()

    init(_ value: T) { self.value = value }

    func read() -> T {
        lock.lock(); defer { lock.unlock() }
        return value
    }

    func write(_ newValue: T) {
        lock.lock(); value = newValue; lock.unlock()
    }
}

let shared = Box<Int>(0)
let a = Task.detached { shared.write(1) }
let b = Task.detached { shared.write(2) }
Task {
    _ = await (a.value, b.value)
    print(shared.read()) // 1 or 2 (last writer wins, but no data race)
}

Best practice

Significato di Sendable

Riepilogo