Swift Academy · Lezione

Il problema delle data race

Comprendi perché la mutazione concorrente non è sicura.

Il problema delle data race è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 1 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'è una data race

Una data race si verifica quando due o più thread accedono contemporaneamente alla stessa area di memoria, almeno uno degli accessi è una scrittura e non esiste alcuna sincronizzazione tra loro.

Il risultato è un comportamento indefinito: valori corrotti, arresti anomali o bug che compaiono solo sotto carico.

Stato mutabile condiviso

La causa principale delle data race è lo stato mutabile condiviso. Se molte task possono leggere e scrivere la stessa variabile, l'ordine delle operazioni diventa imprevedibile.

Il contatore qui sotto può perdere degli incrementi, perché count += 1 è un'operazione di lettura-modifica-scrittura, non atomica.

final class Counter {
    var count = 0
    func increment() {
        count += 1 // read, add, write: not atomic
    }
}

Perché si perdono gli incrementi

L'istruzione count += 1 viene compilata in tre passaggi: caricare il valore, aggiungere uno e memorizzarlo nuovamente.

Se due thread caricano 5 nello stesso momento, entrambi memorizzano 6 e un incremento va perso.

// Thread A loads 5
// Thread B loads 5
// Thread A stores 6
// Thread B stores 6  <-- lost update

Tearing dei valori più grandi

Oltre agli aggiornamenti persi, le scritture concorrenti di valori composti da più word, come una struct o un valore a 64 bit su alcune piattaforme, possono causare tearing: un lettore vede metà di una scrittura e metà di un'altra.

struct Point { var x: Double; var y: Double }
var p = Point(x: 0, y: 0)
// Concurrent writes may leave x from one write and y from another

La vecchia soluzione: i lock

Prima di Swift Concurrency, il rimedio classico era un lock (mutex). Solo un thread alla volta detiene il lock, serializzando gli accessi.

I lock funzionano, ma è facile usarli in modo errato: operazioni di unlock dimenticate, deadlock e inversione di priorità.

import Foundation
final class SafeCounter {
    private let lock = NSLock()
    private var count = 0
    func increment() {
        lock.lock()
        defer { lock.unlock() }
        count += 1
    }
}

Code di dispatch seriali

Un altro approccio classico è una coda di dispatch seriale. Tutte le mutazioni vengono convogliate su un'unica coda, quindi non si sovrappongono mai.

import Foundation
final class QueueCounter {
    private let queue = DispatchQueue(label: "counter")
    private var count = 0
    func increment() {
        queue.async { self.count += 1 }
    }
}

Perché la sincronizzazione manuale è fragile

Lock e code si basano sulla disciplina. Il compilatore non verifica che ogni accesso sia protetto.

Basta una lettura non protetta perché la race si ripresenti. Non esiste alcuna garanzia in fase di compilazione.

// Nothing stops a careless reader from doing this:
// let value = counter.count  // unsynchronized read = race

Swift Concurrency cambia le regole

Swift Concurrency rende la sicurezza rispetto alle data race una funzionalità del linguaggio anziché una convenzione.

Tre strumenti collaborano: actor per lo stato mutabile protetto, Sendable per i tipi sicuri da condividere e il compilatore per far rispettare entrambe le garanzie.

actor Counter {
    private var count = 0
    func increment() { count += 1 }
}

Gli actor serializzano l'accesso

Un actor garantisce che una sola task alla volta esegua il proprio codice che modifica lo stato. Il runtime serializza automaticamente gli accessi.

Non si scrive mai un lock; il modello actor fornisce la sincronizzazione.

actor BankAccount {
    private(set) var balance = 0
    func deposit(_ amount: Int) { balance += amount }
}

Verifica in fase di compilazione

Il compilatore impedisce di accedere allo stato isolato da un actor senza passare dall'actor. Le chiamate tra actor diventano asincrone (await).

Questo trasforma le data race a runtime in errori in fase di compilazione.

let account = BankAccount()
// Must await: balance is actor-isolated
// let b = await account.balance

Sendable delimita ciò che attraversa i thread

Il protocollo Sendable contrassegna i tipi che possono essere passati in sicurezza oltre i confini della concorrenza.

Il compilatore impedisce di inviare stato mutabile non-Sendable a un'altra task, eliminando la race a livello di tipo.

struct Money: Sendable {
    let amount: Int
    let currency: String
}

Verifica rapida: data race

Verifichi la propria comprensione delle cause di una data race.

Riepilogo: il problema delle data race

Le data race derivano da stato mutabile condiviso a cui si accede contemporaneamente senza sincronizzazione, producendo aggiornamenti persi, tearing e comportamento indefinito.

I vecchi rimedi, come lock e code seriali, funzionano, ma non sono verificati e sono fragili. Swift Concurrency sostituisce le convenzioni con verifiche: actor isola lo stato, Sendable delimita ciò che attraversa i confini e il compilatore verifica la sicurezza. Il resto del corso approfondisce questi strumenti.

Domande Frequenti

La lezione «Il problema delle data race» è gratuita?

Sì — il testo completo di «Il problema delle data race» è 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 problema delle data race»?

Comprendi perché la mutazione concorrente non è sicura. 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 1 di 4.

Quanto tempo richiede la lezione «Il problema delle data race»?

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