Letture sporche, non ripetibili e fantasma
Le tre anomalie di lettura e il livello di isolamento che impedisce ciascuna di esse.
Letture sporche, non ripetibili e fantasma è una lezione Coding Interview Prep gratuita su CoddyKit. Questa è la lezione 3 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 Coding Interview Prep, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Coding Interview Prep include 4 lezioni in totale.
Le tre anomalie di lettura
I livelli di isolamento servono a prevenire specifici problemi di concorrenza chiamati anomalie di lettura. Durante i colloqui ci si aspetta che sappia definire con precisione tutte e tre le anomalie e associare ciascuna al livello che la impedisce.
- Lettura sporca - lettura di dati non sottoposti a commit
- Lettura non ripetibile - una riga cambia tra due letture
- Lettura fantasma - nuove righe compaiono tra due letture
La difficoltà consiste nel distinguere la lettura non ripetibile da quella fantasma, perché entrambe comportano l'esecuzione di una nuova query con risultati diversi.
Lettura sporca: definizione
Una lettura sporca si verifica quando la transazione T1 legge una riga che la transazione T2 ha modificato ma non ha ancora sottoposto a commit. Se T2 esegue poi il rollback, T1 ha operato su dati che in realtà non sono mai esistiti.
Solo READ UNCOMMITTED consente le letture sporche. Tutti i livelli superiori le impediscono.
Rischio concreto: approvare un prestito sulla base di un deposito il cui rollback viene eseguito pochi secondi dopo.
Lettura sporca: sequenza temporale
Legga le due colonne come una sequenza temporale. T1 è in esecuzione a livello READ UNCOMMITTED.
T1 vede un saldo di 700, ma T2 non esegue mai il commit. Il valore 700 era un fantasma del lavoro ancora in corso di T2. Dopo il rollback di T2, il valore reale è ancora 500. T1 ha preso una decisione basandosi su dati spazzatura.
-- T2 (not committed) | -- T1 (READ UNCOMMITTED)
BEGIN; |
UPDATE accounts |
SET balance = 700 |
WHERE id = 1; |
| SELECT balance FROM accounts
| WHERE id = 1; -- reads 700 (dirty!)
ROLLBACK; |
| -- T1 acted on a value that never existedLettura non ripetibile: definizione
Una lettura non ripetibile si verifica quando T1 legge una riga, T2 esegue il commit di un aggiornamento o di una cancellazione sulla stessa riga, e T1 la legge di nuovo osservando un valore diverso.
Si noti la differenza fondamentale rispetto a una lettura sporca: in questo caso T2 ha eseguito il commit. I dati sono reali, ma sono cambiati durante l'esecuzione della transazione di T1.
READ COMMITTED consente ancora questo fenomeno. REPEATABLE READ e i livelli superiori lo impediscono leggendo da uno snapshot stabile.
Lettura non ripetibile: sequenza temporale
T1 viene eseguita a livello READ COMMITTED e legge due volte la stessa riga. Tra le due letture, T2 esegue il commit di una modifica.
La stessa chiave primaria restituisce due valori diversi all'interno di un'unica transazione. Questa incoerenza può compromettere la logica composta da più passaggi che presuppone la stabilità della riga.
-- T1 (READ COMMITTED) | -- T2
BEGIN; |
SELECT balance FROM accounts |
WHERE id = 1; -- 500 |
| BEGIN;
| UPDATE accounts SET balance = 900
| WHERE id = 1;
| COMMIT;
SELECT balance FROM accounts |
WHERE id = 1; -- 900 (changed!) |
COMMIT; |Lettura fantasma: definizione
Una lettura fantasma si verifica quando T1 esegue una query con una condizione di ricerca, T2 esegue il commit di un'operazione INSERT (o DELETE) su righe che soddisfano tale condizione, e T1 esegue nuovamente la query ottenendo un insieme di righe diverso.
La differenza rispetto a una lettura non ripetibile è la seguente: la lettura non ripetibile riguarda il cambiamento del valore di una riga esistente; una lettura fantasma riguarda il cambiamento del numero di righe che soddisfano un predicato.
Solo SERIALIZABLE garantisce, secondo lo standard, la prevenzione delle letture fantasma.
Lettura fantasma: sequenza temporale
T1 conta due volte i conti con saldo elevato. Tra i due conteggi, T2 inserisce una nuova riga che soddisfa la condizione ed esegue il commit.
Nessuna riga esistente è cambiata, eppure il risultato di COUNT è diverso. La nuova riga è il "fantasma" comparso nel set di risultati di T1.
-- T1 (REPEATABLE READ, standard) | -- T2
BEGIN; |
SELECT COUNT(*) FROM accounts |
WHERE balance > 1000; -- 3 |
| INSERT INTO accounts(id, balance)
| VALUES (99, 5000);
| COMMIT;
SELECT COUNT(*) FROM accounts |
WHERE balance > 1000; -- 4 (phantom)|
COMMIT; |Associazione delle anomalie ai livelli
Questa associazione è il cuore dell'argomento. Il livello più basso che impedisce ciascuna anomalia è:
- Lettura sporca, impedita da
READ COMMITTEDin poi. - Lettura non ripetibile, impedita da
REPEATABLE READin poi. - Lettura fantasma, impedita da
SERIALIZABLE(secondo lo standard).
Noti la corrispondenza nei nomi: REPEATABLE READ rende le letture ripetibili; i livelli prendono il nome dall'anomalia che risolvono per la prima volta.
Lettura non ripetibile e lettura fantasma: la differenza fondamentale
È la confusione più comune durante i colloqui. Tenga a mente questa frase:
Lettura non ripetibile = è cambiato il valore di una riga esistente. Lettura fantasma = è cambiato l'insieme delle righe corrispondenti (sono state aggiunte o rimosse righe).
Si metta alla prova: T2 esegue UPDATE ... WHERE id = 5 e poi il commit, mentre T1 legge nuovamente la riga 5. Si tratta di una lettura non ripetibile. T2 esegue un INSERT di una nuova riga che soddisfa la clausola WHERE di T1, e T1 esegue nuovamente la query. Si tratta di una lettura fantasma.
Write skew: l'anomalia bonus
Nei colloqui per ruoli senior potrebbe essere richiesto di andare oltre le tre anomalie standard e parlare del write skew: due transazioni leggono ciascuna un insieme parzialmente sovrapposto, eseguono scritture disgiunte sulla base di ciò che hanno letto ed entrambe completano il commit, lasciando uno stato che nessuna delle due avrebbe consentito da sola.
Ecco l'esempio classico: due medici sono di turno; ciascuno verifica che un altro medico sia di turno e poi si toglie dal turno. Entrambi hanno successo, lasciando una copertura pari a zero.
L'isolamento a snapshot (REPEATABLE READ di Postgres) consente il write skew; solo SERIALIZABLE lo impedisce. Menzionarlo dimostra una conoscenza approfondita dell'argomento.
Aggiornamento perso: la quarta insidia
Durante i colloqui a volte viene introdotto l'aggiornamento perso, che non fa parte dell'elenco delle anomalie previsto dallo standard, ma si verifica continuamente nella pratica. Due transazioni leggono lo stesso valore, calcolano entrambe un nuovo valore a partire da quello letto e lo riscrivono. La seconda scrittura sovrascrive silenziosamente la prima.
Esempio: due trasferimenti leggono entrambi un saldo di 500, sottraggono ciascuno un importo e scrivono il proprio risultato. Una delle due sottrazioni viene persa.
La soluzione non consiste semplicemente nell'aumentare il livello di isolamento, ma nell'usare lock espliciti con SELECT ... FOR UPDATE oppure un aggiornamento atomico che esegua il calcolo nel database invece che nell'applicazione.
-- Safe pattern: lock the row, or compute atomically
BEGIN;
SELECT balance FROM accounts WHERE id = 1 FOR UPDATE; -- locks row
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
COMMIT;
-- Or simply: UPDATE accounts SET balance = balance - 100 WHERE id = 1;Verifica rapida
Identifichi l'anomalia a partire dal suo comportamento.
Riepilogo: anomalie e relative soluzioni
Tre anomalie di lettura, ciascuna risolta da un livello di isolamento superiore:
- Lettura sporca (dati non sottoposti a commit), risolta a partire da READ COMMITTED.
- Lettura non ripetibile (cambia il valore di una riga esistente), risolta a partire da REPEATABLE READ.
- Lettura fantasma (cambia l'insieme delle righe corrispondenti), risolta a SERIALIZABLE.
Tenga ben distinta la lettura non ripetibile da quella fantasma e parli del write skew se l'intervistatore desidera approfondire. Ora vediamo come i motori implementano concretamente l'isolamento: lock, deadlock e MVCC.
Domande Frequenti
La lezione «Letture sporche, non ripetibili e fantasma» è gratuita?
Sì — il testo completo di «Letture sporche, non ripetibili e fantasma» è 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 Coding Interview Prep, passa a CoddyKit PRO. Il corso Coding Interview Prep include 4 lezioni in totale.
Cosa imparerò in «Letture sporche, non ripetibili e fantasma»?
Le tre anomalie di lettura e il livello di isolamento che impedisce ciascuna di esse. Eserciti Coding Interview Prep 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 Coding Interview Prep?
Non è richiesta alcuna esperienza precedente. Coding Interview Prep su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Letture sporche, non ripetibili e fantasma»?
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 Coding Interview Prep?
Sì. Ogni lezione Coding Interview Prep 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
- Spiegazione delle proprietà ACID
- I quattro livelli di isolamento
- Letture sporche, non ripetibili e fantasma
- Deadlock, locking e MVCC