Sind C ++ 11 thread_local-Variablen automatisch statisch?

Gibt es einen Unterschied zwischen diesen beiden Codesegmenten:

void f() {
    thread_local vector<int> V;
    V.clear();
    ... // use V as a temporary variable
}

und

void f() {
    static thread_local vector<int> V;
    V.clear();
    ... // use V as a temporary variable
}

Hintergrundgeschichte: Ursprünglich hatte ich einen STATISCHEN Vektor V (zum Halten einiger Zwischenwerte wird er bei jeder Eingabe der Funktion gelöscht) und ein Single-Thread-Programm. Ich möchte das Programm in ein Multithreading-Programm verwandeln, also muss ich diesen statischen Modifikator irgendwie loswerden. Meine Idee ist es, jede Statik in thread_local umzuwandeln und sich um nichts anderes zu kümmern? Kann dieser Ansatz nach hinten losgehen?

Nach dem C ++ Standard

Wenn thread_local auf eine Variable des Blockbereichs angewendet wird, wird der statische Speicherklassenspezifizierer impliziert, wenn er nicht explizit angezeigt wird

Das bedeutet also, dass diese Definition

void f() {
    thread_local vector<int> V;
    V.clear();
    ... // use V as a temporary variable
}

ist äquivalent zu

void f() {
    static thread_local vector<int> V;
    V.clear();
    ... // use V as a temporary variable
}

Eine statische Variable ist jedoch nicht mit einer thread_local-Variablen identisch.

1 Alle mit dem Schlüsselwort thread_local deklarierten Variablen haben eine Thread-Speicherdauer. Die Speicherung für diese Entitäten dauert für die Dauer des Threads, in dem sie erstellt werden. Pro Thread gibt es ein bestimmtes Objekt oder eine bestimmte Referenz. Die Verwendung des deklarierten Namens bezieht sich auf die Entität, die dem aktuellen Thread zugeordnet ist

Zur Unterscheidung dieser Variablen führt der Standard einen neuen Begriff Thread-Speicherdauer zusammen mit statischer Speicherdauer ein.

Ja, "threadlokaler Speicher" ist "global" (oder "statischer Speicher") sehr ähnlich, nur dass anstelle von "Dauer des gesamten Programms" "Dauer des gesamten Threads" angezeigt wird. Daher wird eine blocklokale threadlokale Variable beim ersten Durchlauf der Steuerung durch ihre Deklaration initialisiert, jedoch separat in jedem Thread, und sie wird zerstört, wenn der Thread endet.

Bei Verwendung mit thread_local,static wird angedeutet , in Block-Rahmen (siehe @ Vlad Antwort), für eine Klasse Mitglied requied; Ich denke, bedeutet Verknüpfung für Namespace-Bereich.

Per 9.2 / 6:

Innerhalb einer Klassendefinition darf ein Mitglied nicht mit dem Speicherklassenspezifizierer thread_local deklariert werden, es sei denn, es wird auch als statisch deklariert

So beantworten Sie die ursprüngliche Frage:

Sind C ++ 11 thread_local-Variablen automatisch statisch?

Es gibt keine andere Wahl als Namespace-Scope-Variablen.

Gibt es einen Unterschied zwischen diesen beiden Codesegmenten:

Nein.

Der lokale Thread-Speicher ist statisch, verhält sich jedoch ganz anders als der einfache statische Speicher.

Wenn Sie eine Variable als statisch deklarieren, gibt es genau eine Instanz der Variablen. Das Compiler- / Laufzeitsystem garantiert, dass es irgendwann vor der tatsächlichen Verwendung für Sie initialisiert wird, ohne genau anzugeben, wann (einige Details wurden hier weggelassen).

C ++ 11 garantiert, dass diese Initialisierung threadsicher ist. Vor C ++ 11 wurde diese Thread-Sicherheit jedoch nicht garantiert. Beispielsweise

static X * pointer = new X;

Es können Instanzen von X verloren gehen, wenn mehr als ein Thread gleichzeitig den statischen Initialisierungscode trifft.

Wenn Sie einen Variablenthread lokal deklarieren, gibt es möglicherweise viele Instanzen der Variablen. Sie können sich diese als eine Karte vorstellen, die durch die Thread-ID indiziert wurde. Das bedeutet, dass jeder Thread eine eigene Kopie der Variablen sieht.

Wenn die Variable initialisiert wird, garantiert das Compiler- / Laufzeitsystem erneut, dass diese Initialisierung vor der Verwendung der Daten erfolgt und dass die Initialisierung für jeden Thread erfolgt, der die Variable verwendet. Der Compiler garantiert auch, dass die Initiierung threadsicher ist.

Die Thread-Sicherheitsgarantie bedeutet, dass es hinter den Kulissen eine Menge Code geben kann, damit sich die Variable so verhält, wie Sie es erwarten - insbesondere, wenn man bedenkt, dass der Compiler nicht im Voraus genau wissen kann, wie viele Threads dies tun werden sind in Ihrem Programm vorhanden und wie viele davon berühren die lokale Thread-Variable.