Swift Academy · Lezione

Migrazione alla concorrenza rigorosa

Adotti gradualmente il controllo della concorrenza di Swift 6.

Migrazione alla concorrenza rigorosa è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Che cos'è la concorrenza rigorosa?

Il controllo rigoroso della concorrenza fa sì che il compilatore diagnostichi ogni potenziale data race in fase di compilazione.

Nella modalità linguaggio Swift 6 è attivo per impostazione predefinita; nella modalità Swift 5 potete abilitarlo gradualmente.

I tre livelli di controllo

Il flag -strict-concurrency ha tre livelli: minimal (predefinito in Swift 5), targeted (controlla il codice che usa già la concorrenza) e complete (controllo completo nello stile di Swift 6).

// Build settings example
// SWIFT_STRICT_CONCURRENCY = complete

Adozione graduale

Il percorso consigliato consiste nel passare gradualmente da un livello all'altro: iniziate da targeted, risolvete gli avvisi, quindi passate a complete prima di impostare la modalità linguaggio 6.

In questo modo la migrazione rimane gestibile anche per basi di codice di grandi dimensioni.

// Step 1: targeted
// Step 2: complete (warnings)
// Step 3: Swift 6 mode (errors)

Migrazione per modulo

La concorrenza rigorosa viene configurata per target. Potete migrare un modulo alla volta, lasciando gli altri in modalità Swift 5 finché non saranno pronti.

// Package.swift target
// swiftSettings: [.enableExperimentalFeature("StrictConcurrency")]

Avviso comune: cattura di un valore non-Sendable

La diagnosi più frequente si verifica quando si cattura un valore non-Sendable in un Task o lo si invia oltre il confine di un actor.

Risolvete rendendo il tipo Sendable oppure copiando solo i dati Sendable necessari.

final class Model { var name = "" }
func start(_ m: Model) {
    // Warning: non-Sendable Model captured by Task
    // Task { print(m.name) }
}

Correggere usando i tipi valore

Spesso la soluzione più pulita consiste nel modellare i dati come un tipo valore immutabile, che è automaticamente Sendable.

struct Model: Sendable { let name: String }
func start(_ m: Model) {
    Task { print(m.name) } // safe now
}

Correggere usando @MainActor

I tipi dell'interfaccia utente generano spesso avvisi perché vengono utilizzati da task in background. Annotare il tipo con @MainActor lo vincola al thread principale e risolve gli avvisi.

@MainActor
final class ViewModel {
    var items: [String] = []
    func reload() async {
        let fetched = await load()
        items = fetched
    }
}
func load() async -> [String] { [] }

Conformità a Sendable per i tipi esistenti

Per i tipi sotto il vostro controllo che sono già thread-safe, aggiungete esplicitamente la conformità a Sendable o @unchecked Sendable per eliminare gli avvisi in modo corretto.

import Foundation
final class Counter: @unchecked Sendable {
    private let lock = NSLock()
    private var n = 0
}

Importazioni preconcurrency

Quando una dipendenza non ha ancora annotato la propria API, @preconcurrency import allenta i controlli per quel modulo, trasformando gli errori in avvisi finché non viene aggiornato.

@preconcurrency import SomeLegacyFramework

Contrassegnare i simboli con @preconcurrency

Potete anche contrassegnare singole dichiarazioni con @preconcurrency, così il codice precedente che le chiama non riceve errori quando aggiungete requisiti Sendable.

@preconcurrency
func handle(_ value: Sendable) { }

Verificare la migrazione

Quando il controllo complete non produce più alcun avviso, impostate il target sulla modalità Swift 6, così le garanzie diventano errori obbligatori e non possono regredire.

// Package.swift
// .target(name: "App", swiftSettings: [.swiftLanguageMode(.v6)])

Verifica rapida: migrazione

Verificate la vostra comprensione della migrazione alla concorrenza rigorosa.

Riepilogo: migrazione alla concorrenza rigorosa

Il controllo rigoroso della concorrenza sposta il rilevamento delle data race in fase di compilazione, con i livelli minimal, targeted e complete. Eseguite la migrazione per modulo, correggete le catture non-Sendable usando tipi valore, @MainActor o una conformità Sendable corretta, e usate @preconcurrency per semplificare l'interoperabilità con le dipendenze non ancora migrate.

Quando complete non produce più avvisi, abilitate la modalità Swift 6 per rendere definitive le garanzie.

Domande Frequenti

La lezione «Migrazione alla concorrenza rigorosa» è gratuita?

Sì — il testo completo di «Migrazione alla concorrenza rigorosa» è 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 «Migrazione alla concorrenza rigorosa»?

Adotti gradualmente il controllo della concorrenza di Swift 6. 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 4 di 4.

Quanto tempo richiede la lezione «Migrazione alla concorrenza rigorosa»?

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