Swift Academy · Leçon

Le protocole Sendable

Marquez les types comme sûrs à transférer entre domaines de concurrence.

Le protocole Sendable est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Ce que signifie Sendable

Sendable est un protocole marqueur. Un type qui y adhère garantit qu'il peut être partagé en toute sécurité entre les domaines de concurrence sans introduire de courses aux données.

Il ne possède aucune méthode ; il constitue une garantie de sûreté des threads vérifiée par le compilateur.

protocol Sendable {}

Les types valeur sont souvent Sendable

Les structures et les énumérations dont toutes les propriétés stockées sont Sendable peuvent y adhérer automatiquement.

Comme les valeurs sont copiées lors de leur transmission, chaque tâche reçoit sa propre copie indépendante.

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

Conformité implicite

De nombreux types valeur obtiennent Sendable implicitement : les structures et énumérations figées non publiques dont les membres sont Sendable, les tuples de types Sendable et les métatypes.

Pour les types valeur internes, vous n'avez souvent pas besoin d'écrire : Sendable.

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

Quand une structure est NOT Sendable

Si une structure contient une propriété stockée non-Sendable, elle n'est pas transférable.

Ici, la référence à une classe rend un état mutable partagé accessible, si bien que le compilateur refuse la conformité automatique.

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

Classes et transférabilité

Les classes sont des types référence, leurs copies partagent donc la même instance. Une classe n'est transférable que si elle est finale et que toutes ses propriétés stockées sont immuables et transférables.

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

@unchecked transférable

Parfois, vous savez qu'une classe est sûre en contexte concurrent (elle protège son état avec un lock), mais le compilateur ne peut pas le prouver. Utilisez @unchecked Sendable pour déclarer manuellement qu'elle est sûre.

Il s'agit d'un moyen de contourner les vérifications : vous assumez la responsabilité de la correction.

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
    }
}

Fermetures @Sendable

Les fermetures peuvent également être marquées @Sendable. Une telle fermeture peut être transmise au-delà des frontières de concurrence, le compilateur vérifie donc qu'elle ne capture que des valeurs transférables.

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

La capture d'un état mutable est refusée

Une fermeture @Sendable ne peut pas capturer une variable mutable, car deux tâches pourraient la modifier simultanément.

Le compilateur signale la capture ci-dessous.

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

Transférabilité dans les API asynchrones

Les points d'entrée de la concurrence exigent des valeurs transférables. Les fermetures de Task sont @Sendable, et les valeurs transmises à d'autres acteurs doivent être transférables.

C'est ainsi que le système de types empêche les données qui ne sont pas sûres en contexte concurrent de se propager entre les tâches.

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

Contraintes génériques de transférabilité

Vous pouvez exiger la transférabilité dans les génériques. Une fonction qui lance des tâches avec son argument devrait contraindre cet argument à être Sendable.

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

Transférabilité et acteur

Sendable répond à la question « cette valeur peut-elle être transmise sans danger ? », tandis qu'un actor répond à la question « comment protéger un état mutable ? »

Ils se composent : les acteurs sont implicitement transférables, car l'accès à leur état est sérialisé.

actor Logger { } // actors are implicitly Sendable

Vérification rapide : transférabilité

Vérifiez votre compréhension de la conformité à la transférabilité.

Récapitulatif : le protocole de transférabilité

Sendable marque les types dont le franchissement des frontières de concurrence est sûr. Les types valeur immuables y sont conformes automatiquement ; les classes finales et immuables peuvent y être conformes ; les classes sûres en contexte concurrent utilisent @unchecked Sendable.

Les fermetures @Sendable ne peuvent capturer que des valeurs transférables, et les API asynchrones exigent la transférabilité pour empêcher les partages dangereux. Avec les acteurs, la transférabilité constitue le fondement au niveau des types de la sécurité de Swift face aux courses de données.

Questions Fréquemment Posées

La leçon « Le protocole Sendable » est-elle gratuite ?

Oui — le texte complet de « Le protocole Sendable » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Le protocole Sendable » ?

Marquez les types comme sûrs à transférer entre domaines de concurrence. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Le protocole Sendable » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Swift Academy