KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

thread_local — een eigen variabele voor elke thread

Het sleutelwoord thread_local geeft een variabele een threadopslagduur: elke thread heeft een eigen exemplaar dat tussen functieaanroepen behouden blijft. Het maakt geen gedeelde variabele die tegen gelijktijdige toegang is beschermd.

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

Syntax

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

thread_local geeft een variabele een threadopslagduur. Elke thread heeft een afzonderlijk exemplaar; gebruik van de naam verwijst naar het exemplaar van de huidige thread. Een lokale variabele van dit type behoudt zijn waarde tussen functieaanroepen in dezelfde thread. Een gewone automatische variabele doet dat niet, terwijl een lokale static-variabele zonder thread_local wordt gedeeld door aanroepen vanuit verschillende threads.

In C++23 kan de specificator worden gebruikt voor variabelen op namespace-niveau, variabelen op blokniveau en statische gegevensleden van een klasse, maar niet voor functieparameters of niet-statische gegevensleden. Hij kan worden gecombineerd met static of extern; dat verandert de threadopslagduur niet. Elke declaratie van dezelfde variabele moet thread_local bevatten.

Dynamische initialisatie van een lokale thread_local-variabele vindt plaats wanneer de uitvoering in die thread voor het eerst langs de declaratie komt. Pas dit niet zonder meer toe op de initialisatie van alle variabelen op namespace-niveau. Een geconstrueerd object wordt vernietigd wanneer de thread normaal eindigt, niet wanneer de functie terugkeert. Gebruik geen pointer of referentie naar het object nadat de levensduur ervan is geëindigd.

thread_local is geen vergrendeling en ook geen atomaire bewerking. Een pointer naar een bepaalde instantie delen met een andere thread maakt geen nieuwe kopie en biedt geen synchronisatie. In het voorbeeld verhoogt elke thread zijn eigen count; join() zorgt ervoor dat de worker klaar is voordat de resultaten worden gelezen, waardoor de verwachte uitvoer deterministisch is.

Dit artikel behandelt C++23. De opgegeven bronwebsite bevat een evoluerend werkdocument, geen definitieve publicatie van C++23. Een compileroptie bewijst niet dat iets in een productieomgeving werkt.

Voorbeelden

#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';
}

Resultaat

1 2
1 2
3

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen