Thread-lokaler Speicher (thread_local)
Wenn mehrere Threads denselben Code ausführen und dabei auf globale Variablen zugreifen, teilen sie sich diese Variablen. Änderungen eines Threads sind sofort für alle anderen sichtbar. Das kann zu Race Conditions führen und erfordert Synchronisation. In manchen Situationen ist das unerwünscht. Stattdessen soll jeder Thread seine eigene private Kopie einer Variable haben.
Das Schlüsselwort thread_local markiert eine Variable als thread-lokal.
(Quelle: ISO/IEC 9899:2024, § 6.7.1 Storage-class specifiers)
Jeder Thread erhält eine eigene Instanz dieser Variable. Änderungen wirken sich nur auf den aktuellen Thread aus. Thread-lokale Variablen verhalten sich ansonsten wie normale Variablen.
#include <threads.h>
#include <stdio.h>
thread_local int counter = 0;
int thread_function(void* arg) {
int thread_id = *(int*)arg;
for (int i = 0; i < 5; i++) {
counter++;
printf("Thread %d: counter = %d\n", thread_id, counter);
}
return 0;
}
int main() {
thrd_t t1, t2;
int id1 = 1, id2 = 2;
thrd_create(&t1, thread_function, &id1);
thrd_create(&t2, thread_function, &id2);
thrd_join(t1, nullptr);
thrd_join(t2, nullptr);
}
In diesem Beispiel hat jeder Thread seine eigene counter-Variable. Beide Threads zählen unabhängig voneinander von 1 bis 5, ohne einander zu beeinflussen. Wäre counter eine normale globale Variable, würden beide Threads denselben Zähler hochzählen und einander überschreiben.
Historischer Hinweis: In C11 ist das offizielle Schlüsselwort
_Thread_local. Einige Implementierungen stellen zusätzlich ein Makrothread_localbereit. Seit C23 istthread_localein echtes Schlüsselwort der Sprache und steht ohne weitere Header-Einbindung zur Verfügung. Der alte Name_Thread_localbleibt aus Kompatibilitätsgründen weiterhin gültig.
Initialisierung und Lebensdauer
Die Lebensdauer einer thread_local-Variable ist an den Thread gebunden. Sie existiert so lange, wie der Thread läuft, und wird beim Thread-Ende automatisch freigegeben.
Die Initialisierung erfolgt pro Thread. Sie muss mit einem konstanten Ausdruck erfolgen oder implizit auf Null erfolgen (Zero-Initialization). Die Initialisierung geschieht in der Regel beim Start des Threads.
thread_local int value = 42; // erlaubt: konstanter Ausdruck
thread_local int uninitialized; // implizite Zero-Initialization (Wert 0)
// thread_local int bad = time(nullptr); // FEHLER: kein konstanter Ausdruck
Typische Anwendungsfälle
Thread-lokaler Speicher ist nützlich für Daten, die thread-spezifisch sind, aber im gesamten Thread global verfügbar sein sollen.
-
Fehlerbehandlung: Viele Systembibliotheken verwenden eine globale Variable
errno, um Fehlercodes zu speichern. Würden alle Threads dieselbe Variable teilen, könnten Fehlercodes überschrieben werden, bevor sie ausgewertet wurden. Implementierungen machenerrnodaher thread-lokal (häufig über Makros und interne Thread-Local-Storage-Mechanismen), sodass jeder Thread seine eigene Instanz besitzt und Fehler zuverlässig thread-spezifisch gespeichert werden. -
Zufallszahlengeneratoren haben internen Zustand, der bei jedem Aufruf verändert wird. Wird ein Generator von mehreren Threads gemeinsam genutzt, entstehen Race Conditions. Man könnte Mutexe verwenden, was jedoch die Performance beeinträchtigt. Performanter ist es, jedem Thread einen eigenen Generatorzustand zu geben:
#include <stdlib.h>
thread_local unsigned int seed = 12345;
int thread_safe_rand() {
return rand_r(&seed);
}
- Caching und Puffer: Benötigt eine häufig aufgerufene Funktion temporäre Puffer, kann man diese thread-lokal halten. Der Thread verwendet denselben Puffer wieder, ohne bei jedem Aufruf Speicher zu allozieren. Da jeder Thread seinen eigenen Puffer besitzt, entstehen keine Konflikte und keine Synchronisationskosten.
thread_local char format_buffer[256];
const char* format_value(int value) {
snprintf(format_buffer, sizeof(format_buffer), "Value: %d", value);
return format_buffer;
}
Sichtbarkeit und Deklaration
Thread-lokale Variablen können auf Dateiebene oder innerhalb von Funktionen deklariert werden. Eine globale thread_local-Variable ist in allen Funktionen des Threads sichtbar. Eine static thread_local-Variable innerhalb einer Funktion ist nur dort sichtbar, behält ihren Wert aber über mehrere Funktionsaufrufe hinweg, jeweils pro Thread.
thread_local int global_tls; // In allen Funktionen sichtbar
void function() {
static thread_local int local_tls; // Nur in dieser Funktion sichtbar
}
thread_local erfordert static storage duration und kann daher nicht mit automatischen (stack-basierten) Variablen ohne static kombiniert werden.
Einschränkungen und typische Fehler
Thread-lokale Variablen sind ein weiterer, klar abgegrenzter Speicherbereich. Damit existieren lokale Variablen auf dem Stack, globale und statische Variablen mit Programmlaufzeit bzw. Gültigkeit innerhalb einer Translation-Unit, dynamische Daten auf dem Heap sowie thread-lokale Variablen, die Daten eindeutig einem Thread zuordnen.
Wie bei allen Speicherarten ergeben sich auch bei thread-lokalen Variablen einige Fehlerquellen, auf die man achten sollte:
-
Speicherverbrauch: Thread-lokale Variablen verbrauchen Speicher pro Thread. Der Speicherbedarf multipliziert sich mit der Anzahl der Threads. Große
thread_local-Objekte oder Arrays können bei vielen Threads schnell problematisch werden und sollten sparsam eingesetzt werden. -
Keine Thread-Kommunikation: Thread-lokale Variablen eignen sich nicht zur Kommunikation zwischen Threads. Jeder Thread sieht ausschließlich seine eigene Kopie. Änderungen bleiben strikt lokal. Für den Datenaustausch sind gemeinsame Variablen mit geeigneter Synchronisation (Mutexe, atomare Operationen) notwendig.
-
Zeiger über Thread-Grenzen: Ein häufiger Fehler ist das Weiterreichen von Zeigern auf thread-lokale Variablen an andere Threads:
thread_local int data = 0;
void* dangerous_function(void* arg) {
int* ptr = &data; // Zeiger auf thread-lokale Variable
// Diesen Zeiger an einen anderen Thread weitergeben.
// Das ist undefiniertes Verhalten!
return ptr;
}
Der empfangende Thread greift dann auf Speicher zu, der nicht zu ihm gehört. Das kann zu Speicherzugriffsverletzungen oder subtilen Bugs führen. Thread-lokale Daten sollten nur innerhalb des Threads verwendet werden, dem sie zugeordnet sind.
- Performance-Overhead: Der Zugriff auf thread-lokale Variablen ist minimal langsamer als auf normale globale Variablen, da die Laufzeitumgebung die thread-spezifische Instanz ermitteln muss (meist über Thread-Local Storage, TLS). Für die meisten Anwendungen ist dieser Overhead vernachlässigbar, kann aber bei extrem Performance-kritischen Schleifen relevant werden.
Thread-Specific Storage (TSS)
Neben dem Sprachmerkmal thread_local stellt die C-Standardbibliothek eine explizite API für thread-spezifischen Speicher bereit: Thread-Specific Storage (TSS). (Quelle: ISO/IEC 9899:2024, § 7.28.6 Thread-specific storage functions)
TSS erlaubt es, pro Thread Daten zu speichern, ohne dafür globale thread_local-Variablen zu verwenden. Stattdessen werden Schlüssel (tss_t) erzeugt, unter denen jeder Thread einen eigenen Zeigerwert ablegen kann. Die Lebensdauer der Daten ist an den Thread gebunden, optional mit einer Destruktorfunktion, die beim Thread-Ende aufgerufen wird.
TSS ist primär für Bibliotheken relevant, die thread-spezifische Zustände verwalten müssen, ohne dem Benutzer globale Variablen aufzuzwingen. Für Anwendungs-Code ist thread_local in der Regel einfacher, übersichtlicher und vorzuziehen. TSS ergänzt das Modell dort, wo sprachliche Thread-Lokalität nicht ausreicht oder nicht einsetzbar ist.