Swift Academy · Lezione

Il protocollo Sendable

Contrassegni i tipi come sicuri per attraversare i domini di concorrenza.

Il protocollo Sendable è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Cosa significa Sendable

Sendable è un protocollo marker. Un tipo che vi aderisce garantisce di essere sicuro da condividere tra domini di concorrenza senza introdurre data race.

Non contiene metodi; è una garanzia sulla sicurezza rispetto ai thread verificata dal compilatore.

protocol Sendable {}

I tipi valore sono spesso Sendable

Struct ed enum le cui proprietà memorizzate sono tutte Sendable possono conformarsi automaticamente.

Poiché i valori vengono copiati quando vengono passati, ogni task riceve una copia indipendente.

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

Conformità implicita

Molti tipi valore ottengono Sendable in modo implicito: struct ed enum frozen non pubblici con membri Sendable, tuple di tipi Sendable e metatipi.

Spesso non è necessario scrivere affatto : Sendable per i tipi valore interni.

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

Quando una struct NON è Sendable

Se una struct contiene una proprietà memorizzata non-Sendable, non è Sendable.

In questo caso, il riferimento alla classe rende raggiungibile uno stato mutabile condiviso, quindi il compilatore rifiuta la conformità automatica.

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

Classi e Sendable

Le classi sono tipi riferimento, quindi le copie condividono la stessa istanza. Una classe è Sendable solo se è final e tutte le sue proprietà memorizzate sono immutabili e Sendable.

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

@unchecked Sendable

A volte si sa che una classe è thread-safe (protegge lo stato con un lock), ma il compilatore non è in grado di dimostrarlo. Usate @unchecked Sendable per dichiarare manualmente che è sicura.

È una soluzione di ripiego: siete voi a essere responsabili della correttezza.

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

Closure @Sendable

Anche le closure possono essere contrassegnate con @Sendable. Una closure di questo tipo può essere passata oltre i confini della concorrenza, quindi il compilatore verifica che catturi solo valori Sendable.

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

La cattura di stato mutabile viene rifiutata

Una closure @Sendable non può catturare una variabile mutabile, perché due task potrebbero modificarla contemporaneamente.

Il compilatore segnala la cattura riportata di seguito.

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

Sendable nelle API asincrone

I punti di ingresso della concorrenza richiedono Sendable. Le closure di Task sono @Sendable e i valori passati ad altri actor devono essere Sendable.

È così che il sistema dei tipi impedisce ai dati non thread-safe di propagarsi tra i task.

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

Vincoli Sendable generici

Potete richiedere Sendable nei generics. Una funzione che avvia task usando il proprio argomento dovrebbe vincolare tale argomento a Sendable.

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

Sendable e actor

Sendable risponde alla domanda «è sicuro passare questo valore?», mentre un actor risponde alla domanda «come proteggo lo stato mutabile?»

Si combinano: gli actor sono implicitamente Sendable perché l'accesso al loro stato è serializzato.

actor Logger { } // actors are implicitly Sendable

Verifica rapida: Sendable

Verificate la vostra comprensione della conformità a Sendable.

Riepilogo: il protocollo Sendable

Sendable indica i tipi che possono attraversare in sicurezza i confini della concorrenza. I tipi valore immutabili sono conformi automaticamente; le classi final immutabili possono essere conformi; le classi thread-safe usano @unchecked Sendable.

Le closure @Sendable possono catturare solo valori Sendable e le API asincrone richiedono Sendable per impedire la condivisione non sicura. Insieme agli actor, Sendable costituisce la base a livello di tipi per la sicurezza di Swift rispetto alle data race.

Domande Frequenti

La lezione «Il protocollo Sendable» è gratuita?

Sì — il testo completo di «Il protocollo Sendable» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Il protocollo Sendable»?

Contrassegni i tipi come sicuri per attraversare i domini di concorrenza. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Il protocollo Sendable»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Swift Academy