std::atomic e memory order
Usi std::atomic con il memory ordering corretto per garantire correttezza e velocità
std::atomic e memory order è una lezione C++ 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 C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.
Oltre i mutex
I lock serializzano gli accessi: sono semplici e corretti, ma limitano il throughput. std::atomic fornisce elementi costitutivi lock-free per il codice concorrente ad alto throughput.
Nozioni di base su std::atomic
Un std::atomic<T> racchiude un valore e supporta operazioni atomiche di lettura-modifica-scrittura.
#include <atomic>
std::atomic<int> counter{0};
counter.fetch_add(1); // atomic increment
int v = counter.load();
counter.store(0);Operatori di praticità
Per i tipi aritmetici, i normali operatori sono atomici.
std::atomic<int> n{0};
++n; // atomic increment
n += 5; // atomic add
int v = n; // atomic loadPerché gli atomic sono complessi
La CPU può riordinare le operazioni di memoria tra i core. L'ordine di memoria specifica quali riordinamenti sono consentiti.
Ordini di memoria
Cinque ordini comuni:
memory_order_relaxed— atomico, ma senza ordinamentomemory_order_acquire— da abbinare a release; nessun riordinamento successivomemory_order_release— da abbinare ad acquire; nessun riordinamento precedentememory_order_acq_rel— entrambimemory_order_seq_cst— sequenzialmente consistente (predefinito)
Consistenza sequenziale: un'impostazione predefinita sicura
L'impostazione predefinita seq_cst si comporta in modo intuitivo: tutti gli atomic sembrano essere eseguiti in un unico ordine globale. È più lenta degli ordini relaxed, ma più facile da analizzare.
Abbinamento acquire-release
Utilizzare release nel producer e acquire nel consumer. Dopo acquire, tutte le scritture avvenute prima del release corrispondente sono visibili.
std::atomic<bool> ready{false};
int data = 0;
// producer
data = 42;
ready.store(true, std::memory_order_release);
// consumer
while (!ready.load(std::memory_order_acquire));
std::cout << data; // sees 42Ordine relaxed
Gli atomic relaxed garantiscono l'atomicità, evitando letture parziali, ma consentono qualsiasi riordinamento. Utilizzarli per semplici contatori quando l'ordinamento non è importante.
Confronto e scambio
La base della maggior parte degli algoritmi lock-free. compare_exchange_strong(expected, desired) aggiorna il valore atomicamente solo se il valore corrente è uguale a expected.
std::atomic<int> a{10};
int expected = 10;
bool ok = a.compare_exchange_strong(expected, 20);
// if true, a is now 20; otherwise expected holds the actual current valueCAS debole e forte
compare_exchange_weak può fallire falsamente anche quando i valori coincidono. Utilizzarlo all'interno dei cicli, perché su alcune piattaforme è più economico; utilizzare strong al di fuori dei cicli.
Lock-free e wait-free
Due garanzie di avanzamento:
- Lock-free — almeno un thread avanza in qualsiasi momento
- Wait-free — ogni thread avanza entro un tempo limitato
Quando utilizzare gli atomic
Gli atomic non sono sempre più veloci dei mutex. Utilizzarli quando è possibile mantenere semplice il percorso critico, ad esempio per contatori, flag e stati semplici. Per uno stato condiviso complesso, i mutex sono generalmente più sicuri e più chiari.
Verifica rapida
Quale ordine di memoria offre le garanzie più forti, ma è anche il più lento?
Riepilogo
std::atomic fornisce primitive lock-free con un ordinamento della memoria esplicito. Utilizzare per impostazione predefinita memory_order_seq_cst; usare coppie acquire/release per gli schemi producer-consumer e relaxed solo per operazioni atomiche non ordinate, come i contatori.
Impara C++ con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 51
- Lezioni
- 203
Domande Frequenti
La lezione «std::atomic e memory order» è gratuita?
Sì — il testo completo di «std::atomic e memory order» è 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 C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.
Cosa imparerò in «std::atomic e memory order»?
Usi std::atomic con il memory ordering corretto per garantire correttezza e velocità Eserciti C++ 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 C++ Academy?
Non è richiesta alcuna esperienza precedente. C++ 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 «std::atomic e memory order»?
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 C++ Academy?
Sì. Ogni lezione C++ 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
- std::atomic e memory order
- Pattern compare-and-swap (CAS)
- Implementazione di una coda lock-free
- Hazard pointer e problema ABA