Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

thread_local — una variabile distinta per ogni thread

La parola chiave thread_local assegna a una variabile una durata di memorizzazione per thread: ogni thread ha una propria istanza, mantenuta tra le chiamate di funzione. Non crea un’unica variabile condivisa protetta dagli accessi concorrenti.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

thread_local T name = initializer;
static thread_local T name = initializer;
extern thread_local T name;

thread_local assegna a una variabile una durata di memorizzazione per thread. Ogni thread ha un’istanza distinta e l’uso del nome si riferisce all’istanza del thread corrente. Una variabile locale di questo tipo mantiene il proprio valore tra le chiamate di funzione nello stesso thread. Una normale variabile automatica non lo fa, mentre una variabile locale static senza thread_local è condivisa dalle chiamate provenienti da thread diversi.

In C++23 lo specificatore può essere usato per variabili con ambito di namespace, variabili con ambito di blocco e membri dati statici di una classe, ma non per parametri di funzione o membri dati non statici. Può essere combinato con static o extern; ciò non modifica la durata di memorizzazione per thread. Ogni dichiarazione della stessa variabile deve includere thread_local.

L’inizializzazione dinamica di una variabile locale thread_local avviene la prima volta che il flusso di controllo passa per la sua dichiarazione in quel thread. Non estendere questa regola all’inizializzazione di tutte le variabili con ambito di namespace. Un oggetto costruito viene distrutto alla normale terminazione del suo thread, non quando la funzione termina. Non usare un puntatore o un riferimento a quell’oggetto dopo la fine della sua durata.

thread_local non è né un blocco né un’operazione atomica. Condividere con un altro thread un puntatore a una specifica istanza non crea una nuova copia e non fornisce sincronizzazione. Nell’esempio, ogni thread incrementa il proprio count; join() garantisce che il thread di lavoro termini prima che i risultati vengano letti, rendendo deterministico l’output atteso.

Questa voce riguarda C++23. Il sito sorgente indicato ospita una bozza di lavoro in evoluzione, non una pubblicazione definitiva di C++23. Un’opzione del compilatore non dimostra il funzionamento in un ambiente di produzione.

Esempi

#include <iostream>
#include <thread>

int next() {
    thread_local int count = 0;
    return ++count;
}

int main() {
    const int first = next();
    const int second = next();
    int workerFirst = 0;
    int workerSecond = 0;

    std::thread worker([&] {
        workerFirst = next();
        workerSecond = next();
    });
    worker.join();

    std::cout << first << ' ' << second << '\n';
    std::cout << workerFirst << ' ' << workerSecond << '\n';
    std::cout << next() << '\n';
}

Risultato

1 2
1 2
3

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti