Sendable — vad är det, protokoll för trådsäkerhet

Vad är Sendable-protokollet i Swift?

Sendable — är ett protokoll från Swifts standardbibliotek (SE-0302) som markerar typer som är säkra att överföra mellan isoleringsdomäner. Med isoleringsdomän avses en actor, en Task-uppgift eller en @MainActor-kontext. Sendable innehåller inga krav — det fungerar som en säkerhetsmarkör.

Varför Sendable behövs

Före Swift 5.5 kunde utvecklare överföra vilket objekt som helst mellan trådar via DispatchQueue, och kompilatorn kontrollerade inte om det var säkert. Sendable täpper till detta hål: nu övervakar kompilatorn själv överföringar mellan trådar och blockerar osäkra sådana. Detta gör konkurrent kod mer tillförlitlig redan innan den körs.

struct UserProfile: Sendable {
    let name: String
    let age: Int
}

class NonSendableClass {
    var counter: Int = 0
}

I exemplet kan UserProfile säkert överföras mellan trådar eftersom det är en struktur med konstanta egenskaper av Sendable-typer. NonSendableClass orsakar ett kompileringsfel vid försök att överföra via await eller till Task.

Vilka typer följer Sendable som standard

Sendable-typer i Swift delas in i tre kategorier: värdetyper med Sendable-egenskaper, slutgiltiga klasser med oföränderligt tillstånd och funktioner/slutningar markerade med @Sendable. Kompilatorn härleder automatiskt överensstämmelse med Sendable för värdetyper.

Värdetyper och automatisk överensstämmelse

Struct, enum och tuple blir automatiskt Sendable om alla deras egenskaper och associerade värden också är Sendable. Detta är ett konservativt tillvägagångssätt: om även en enda egenskap inte följer Sendable kommer hela typen inte att anses säker.

Grundtyper

Alla inbyggda Swift-typer — Int, String, Double, Bool, Optional, Array, Dictionary, Set — följer Sendable. Detta gör typsammansättning som standard säker. Utvecklaren behöver bara vara uppmärksam på anpassade klasser.

Sendable och klasser: @unchecked Sendable

@unchecked Sendable — är en mekanism som gör att en klass explicit kan deklarera sig som Sendable och kringgå kompilatorns kontroller. Utvecklaren tar ansvar för trådsäkerheten för en sådan klass. Detta är användbart för Objective-C-bryggor och optimerade strukturer.

När ska @unchecked Sendable användas

@unchecked Sendable tillämpas när en klass internt garanterar säkerhet genom lås eller atomära operationer, men kompilatorn inte kan kontrollera detta statiskt. Till exempel en klass med os_unfair_lock eller pthread_mutex_t — dess trådsäkerhet säkerställs av koden, men Swift ser inte detta.

final class AtomicCounter: @unchecked Sendable {
    private var value: Int = 0
    private let lock = NSLock()
    
    func increment() {
        lock.lock()
        value += 1
        lock.unlock()
    }
}

Använd @unchecked Sendable försiktigt. Detta är en tydlig signal till andra utvecklare: ”Jag har kontrollerat, det är säkert”. Ett fel i implementeringen kan leda till svårupptäckta race-förhållanden. Innan du tillämpar @unchecked, se till att typen verkligen inte kan skrivas om som en värdetyp.

Sendable i kombination med Actor

Actor och Sendable är två sidor av samma mynt. Actor isolerar sitt tillstånd, men för datautbyte med omvärlden måste den returnera Sendable-typer. Om en actormetod returnerar en icke-Sendable-typ, ger kompilatorn en varning eller ett fel.

Dataöverföring via Sendable

När en actor skickar data till extern kod passerar dessa data isoleringsgränsen. Sendable garanterar att mottagaren kan använda dem säkert utanför aktorn. Själva aktorn förblir isolerad — dess interna tillstånd avslöjas inte.

struct AccountSnapshot: Sendable {
    let id: UUID
    let balance: Double
    let lastUpdated: Date
}

actor BankActor {
    private var balance: Double = 0
    
    func snapshot() async -> AccountSnapshot {
        return AccountSnapshot(
            id: UUID(),
            balance: balance,
            lastUpdated: Date()
        )
    }
}

AccountSnapshot — är en Sendable-struktur som endast innehåller let-egenskaper av Sendable-typer. Detta tillvägagångssätt är best practice för att extrahera data från en actor. En ögonblicksbild av tillståndet överförs efter värde och aktorn förlorar inte kontrollen över sitt tillstånd.

Sendable-funktioner och slutningar

@Sendable — är ett attribut för funktioner och slutningar som garanterar att slutningen inte fångar icke-Sendable-data på ett muterbart sätt. När en slutning skickas till Task eller en actormetod måste den vara Sendable.

Kontroll av infångning i @Sendable-slutningar

Kompilatorn kontrollerar att @Sendable-slutningen inte fångar muterbara referenser till klasser. Infångning av let-egenskaper av Sendable-typer är tillåtet. Infångning av en var-variabel av referenstyp orsakar ett fel, eftersom slutningen kan köras samtidigt med mutation.

func performAsync(operation: @Sendable () -> Void) {
    Task {
        await operation()
    }
}

let constant = "Safe"
var counter = 0
// counter — att fånga var muterar räknaren, kompileringsfel
performAsync { // ❌ Mutation av fångad var
    print(constant)
}

Regeln är enkel: en @Sendable-slutning kan bara fånga sådan data som själv är Sendable och inte kommer att muteras utifrån. För klasser är infångning av weak self-referens tillåten om klassen inte är markerad som Sendable. Detta förhindrar klassiska retain-cykler och race-förhållanden.