Swift Academy · Lektion

Das Sendable-Protocol

Kennzeichnen Sie Typen als sicher für den Wechsel zwischen Nebenläufigkeitsdomänen.

Das Sendable-Protocol ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was Sendable bedeutet

Sendable ist ein Markerprotokoll. Ein Typ, der diesem Protokoll entspricht, verspricht, dass er sicher über Nebenläufigkeitsbereiche hinweg geteilt werden kann, ohne Data Races zu verursachen.

Es besitzt keine Methoden, sondern ist eine vom Compiler geprüfte Garantie für Thread-Sicherheit.

protocol Sendable {}

Value Types sind häufig Sendable

Structs und Enums, deren gespeicherte Properties alle Sendable sind, können diesem Protokoll automatisch entsprechen.

Da Werte bei der Übergabe kopiert werden, erhält jeder Task eine eigene, unabhängige Kopie.

struct User: Sendable {
    let id: Int
    let name: String
}

Implizite Konformität

Viele Value Types erhalten Sendable implizit: nicht öffentliche eingefrorene Structs und Enums mit Sendable-Mitgliedern, Tupel aus Sendable-Typen und Metatypes.

Für interne Value Types müssen Sie häufig überhaupt kein : Sendable schreiben.

enum Direction { case north, south, east, west }
// Implicitly Sendable: no associated non-Sendable data

Wann eine Struct NICHT Sendable ist

Wenn ein Struct eine gespeicherte Eigenschaft besitzt, die nicht Sendable ist, ist es nicht Sendable.

Hier macht die Klassenreferenz gemeinsam genutzten veränderlichen Zustand erreichbar, weshalb der Compiler die automatische Konformität verweigert.

final class Box { var value = 0 }
struct Wrapper { // not Sendable
    let box: Box // class with mutable state
}

Klassen und Sendable

Klassen sind Referenztypen, daher verwenden Kopien dieselbe Instanz. Eine Klasse ist nur dann Sendable, wenn sie final ist und alle ihre gespeicherten Eigenschaften unveränderlich und Sendable sind.

final class ImmutablePoint: Sendable {
    let x: Double
    let y: Double
    init(x: Double, y: Double) { self.x = x; self.y = y }
}

@unchecked Sendable

Manchmal wissen Sie, dass eine Klasse threadsicher ist (weil sie ihren Zustand mit einer Sperre schützt), der Compiler dies aber nicht nachweisen kann. Verwenden Sie @unchecked Sendable, um die Sicherheit manuell zu bestätigen.

Dies ist ein Ausweg: Sie übernehmen die Verantwortung für die Korrektheit.

import Foundation
final class Cache: @unchecked Sendable {
    private let lock = NSLock()
    private var storage: [String: Int] = [:]
    func set(_ k: String, _ v: Int) {
        lock.lock(); defer { lock.unlock() }
        storage[k] = v
    }
}

@Sendable-Closures

Auch Closures können mit @Sendable markiert werden. Eine solche Closure darf über Nebenläufigkeitsgrenzen hinweg übergeben werden, daher überprüft der Compiler, dass sie nur Sendable-Werte erfasst.

func run(_ work: @Sendable () -> Void) {
    work()
}
let name = "Ada" // immutable, Sendable
run { print(name) }

Das Erfassen veränderlichen Zustands wird abgelehnt

Eine @Sendable-Closure kann keine veränderliche Variable erfassen, da zwei Tasks sie gleichzeitig verändern könnten.

Der Compiler meldet das Erfassen im folgenden Beispiel.

var counter = 0
// Error: @Sendable closure captures mutable var
// run { counter += 1 }

Sendable in asynchronen APIs

Einstiegspunkte für Nebenläufigkeit erfordern Sendable. Task-Closures sind @Sendable, und an andere Actors übergebene Werte müssen Sendable sein.

Auf diese Weise verhindert das Typsystem, dass nicht threadsichere Daten über Tasks hinweg weitergegeben werden.

func process(_ user: User) async {
    Task {
        // user is Sendable, safe to capture
        print(user.name)
    }
}

Generische Sendable-Einschränkungen

Sie können Sendable in Generics voraussetzen. Eine Funktion, die mit ihrem Argument Tasks startet, sollte dieses Argument auf Sendable beschränken.

func dispatch<T: Sendable>(_ value: T) {
    Task { print(value) }
}

Sendable im Vergleich zu Actor

Sendable beantwortet die Frage „Ist dieser Wert sicher zu übertragen?“, während ein actor die Frage beantwortet: „Wie schütze ich veränderlichen Zustand?“

Beide ergänzen einander: Actors sind implizit Sendable, da der Zugriff auf ihren Zustand serialisiert wird.

actor Logger { } // actors are implicitly Sendable

Schnelltest: Sendable

Testen Sie Ihr Verständnis der Sendable-Konformität.

Zusammenfassung: Das Sendable-Protokoll

Sendable kennzeichnet Typen, die sicher Nebenläufigkeitsgrenzen überschreiten können. Unveränderliche Werttypen erhalten automatisch die Konformität; unveränderliche finale Klassen können konform sein; threadsichere Klassen verwenden @unchecked Sendable.

@Sendable-Closures dürfen nur Sendable-Werte erfassen, und asynchrone APIs erfordern Sendable, um unsichere gemeinsame Nutzung zu verhindern. Zusammen mit Actors bildet Sendable die Grundlage der Swift-Typsicherheit gegen Datenrennen.

Häufig gestellte Fragen

Ist die Lektion „Das Sendable-Protocol“ kostenlos?

Ja — der vollständige Text von „Das Sendable-Protocol“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Das Sendable-Protocol“?

Kennzeichnen Sie Typen als sicher für den Wechsel zwischen Nebenläufigkeitsdomänen. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Das Sendable-Protocol“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Swift Academy