Synchronisation mit Mutex
Man stelle sich eine Küche vor. Eine Person backt einen Schokoladenkuchen und wiegt Mehl ab, schlägt Eier auf und rührt den Teig. Diese Schritte gehören zusammen und müssen in genau dieser Reihenfolge ausgeführt werden.
Greift nun eine zweite Person währenddessen in denselben Arbeitsprozess ein, benutzt dieselbe Schüssel und mischt parallel ein Chili-Rezept hinein, entsteht ein Chili-Schoko-Kuchen-Albtraum. Das liegt nicht daran, dass ein einzelner Schritt falsch war, sondern daran, dass zusammengehörige Schritte gleichzeitig verändert wurden.
Was hier fehlt, ist eine einfache Regel: Während ein Thread mit der Ressource arbeitet, darf kein anderer Thread darauf zugreifen. Erst nach Abschluss des Vorgangs wird die Ressource wieder freigegeben.
Mutex
Ein Mutex setzt genau dieses Prinzip in einem nebenläufigen C-Programm um. Der Name steht für mutual exclusion. Er stellt sicher, dass immer nur ein Thread gleichzeitig einen bestimmten Abschnitt betreten kann. Alle anderen Threads warten, bis der Mutex freigegeben wird.
Ein Mutex geht damit über eine atomare Operation hinaus. Atomar bedeutet lediglich, dass ein einzelner Zugriff unteilbar ausgeführt wird, etwa ein Lesen oder Schreiben einer Variablen. Ein Mutex schützt dagegen mehrere logisch zusammengehörige Schritte. Ein solcher Bereich wird als kritischer Abschnitt bezeichnet.
Mutex-Datentyp mtx_t und Funktionen
Die Struktur mtx_t aus <threads.h> repräsentiert einen Mutex.
(Quelle: ISO/IEC 9899:2024, § 7.28.1 Introduction)
Die interne Struktur ist implementationsabhängig. Ein Mutex-Typ muss vor der Benutzung immer initialisiert werden. Das macht die Funktion mtx_init()
(Quelle: ISO/IEC 9899:2024, § 7.28.4.3 The mtx_init function)
:
int mtx_init(mtx_t *mtx, int type);
type ist meist mtx_plain.
Die wichtigsten Operationen sind das Markieren eines kritischen Abschnittes und das Verlassen eines kritischen Abschnittes. Dafür gibt es zwei Funktionen:
int mtx_lock(mtx_t *mtx);Sperrt den Mutex. (Quelle: ISO/IEC 9899:2024, § 7.28.4.4 The mtx_lock function) Blockiert, falls ein anderer Thread ihn bereits hält.int mtx_unlock(mtx_t *mtx);Gibt den Mutex wieder frei. (Quelle: ISO/IEC 9899:2024, § 7.28.4.6 The mtx_unlock function)
Zu der Initialisierungsfunktion gibt es eine symmetrische Funktion zum Freigeben des Mutex:
void mtx_destroy(mtx_t *mtx);: Räumt Ressourcen auf. (Quelle: ISO/IEC 9899:2024, § 7.28.4.2 The mtx_destroy function) Darf nur aufgerufen werden, wenn der Mutex nicht mehr benutzt wird.
Beispiel: Threadsicherer Stack
Datenstrukturen sind ein zentrales Element praktisch jedes Programms. Sie kapseln Zustände und stellen Operationen bereit, mit denen dieser Zustand gelesen und verändert wird. In vielen Fällen besteht eine solche Operation nicht aus einem einzelnen Zugriff, sondern aus mehreren logisch zusammengehörigen Schritten: prüfen, entscheiden, schreiben, aktualisieren.
Solange ein Programm nur einen Thread verwendet, ist das unproblematisch. In nebenläufigen Programmen ändert sich das jedoch grundlegend. Greifen mehrere Threads gleichzeitig auf dieselbe Datenstruktur zu, können sich ihre Operationen gegenseitig überlagern. Prüfungen auf Gültigkeit und darauffolgende Änderungen erfolgen dann nicht mehr als zusammenhängende Einheit, sondern werden zeitlich ineinander verschachtelt.
Das führt zu klassischen Fehlerbildern:
- Ein Thread prüft einen Zustand, der im nächsten Moment von einem anderen Thread verändert wird.
- Mehrere Threads verändern denselben internen Zustand parallel.
- Annahmen, die innerhalb einer Operation gelten sollten, sind plötzlich nicht mehr erfüllt.
In der Folge kann die Datenstruktur inkonsistent werden oder vollständig ›kaputtgehen‹.
Ein Stack ist ein einfaches Beispiel für dieses Problem. Er besteht typischerweise aus einem Speicherbereich (ein Array) und einem Index, der angibt, wie viele Elemente aktuell enthalten sind. Eine push-Operation prüft, ob noch Platz vorhanden ist, schreibt ein Element und erhöht anschließend den Index. Eine pop-Operation prüft, ob der Stack nicht leer ist, verringert den Index und liest das Element.
Werden push und pop von mehreren Threads gleichzeitig ausgeführt, ohne dass diese Schritte gemeinsam geschützt werden, können genau diese Annahmen verletzt werden. Zwei Threads können denselben Index verwenden, sich gegenseitig überschreiben oder annehmen, der Stack sei leer oder voll, obwohl er es im nächsten Moment nicht mehr ist.
Im folgenden Beispiel wird dieses Problem dargestellt. Zwei Threads greifen gleichzeitig auf einen gemeinsamen Stack zu. Einer legt Werte ab, der andere entfernt sie. Der Stack besteht lediglich aus einem Array und einem Index (top).
Ein Schalter (USE_MUTEX) entscheidet, ob der Zugriff geschützt wird oder nicht.
Der Stack wird absichtlich mit einem bekannten Anfangswert gestartet. Am Ende des Programms wird geprüft, ob dieser Wert wieder erreicht wurde. Ist das nicht der Fall, wurde der gemeinsame Zustand beschädigt.
#include <stdio.h>
#include <threads.h>
#include <stdlib.h>
#define USE_MUTEX 0
#if USE_MUTEX
#define LOCK(m) mtx_lock(&(m))
#define UNLOCK(m) mtx_unlock(&(m))
#else
#define LOCK(m) ((void)0)
#define UNLOCK(m) ((void)0)
#endif
constexpr int CAP = 64;
typedef struct {
mtx_t lock;
int data[CAP];
int top; // 0..CAP
} Stack;
static Stack stack;
static bool push(int v) {
LOCK(stack.lock);
if (stack.top >= CAP) {
UNLOCK(stack.lock);
return false;
}
stack.data[stack.top++] = v;
UNLOCK(stack.lock);
return true;
}
static bool pop(int *out) {
LOCK(stack.lock);
if (stack.top <= 0) {
UNLOCK(stack.lock);
return false;
}
*out = stack.data[--stack.top];
UNLOCK(stack.lock);
return true;
}
constexpr int OPS = 1000;
static int pusher([[maybe_unused]] void *arg) {
for (int i = 0; i < OPS; i++) {
while (!push(i)) thrd_yield();
}
return 0;
}
static int popper([[maybe_unused]] void *arg) {
int v;
for (int i = 0; i < OPS; i++) {
while (!pop(&v)) thrd_yield();
}
return 0;
}
constexpr int MARKER = 42;
int main() {
if (mtx_init(&stack.lock, mtx_plain) != thrd_success) {
return EXIT_FAILURE;
}
stack.top = MARKER;
thrd_t a, b;
if (thrd_create(&a, pusher, nullptr) != thrd_success) {
return EXIT_FAILURE;
}
if (thrd_create(&b, popper, nullptr) != thrd_success) {
return EXIT_FAILURE;
}
thrd_join(a, nullptr);
thrd_join(b, nullptr);
printf("USE_MUTEX=%d top=%d\n", USE_MUTEX, stack.top);
mtx_destroy(&stack.lock);
if (stack.top != MARKER) puts("Inkonsistenter Zustand");
}
Der Stack besteht nur aus zwei Dingen: einem Array für die Daten und einem Index top, der angibt, wie viele Elemente aktuell enthalten sind. Dieser Index beschreibt nicht nur eine Zahl, sondern eine Invariante: Er muss immer im gültigen Bereich liegen und exakt zur Belegung des Arrays passen.
Sowohl push als auch pop arbeiten in mehreren Schritten:
-
pushprüft, ob noch Platz vorhanden ist, schreibt ein Element und erhöht anschließendtop. -
popprüft, ob der Stack nicht leer ist, verringerttopund liest dann das Element.
Diese Schritte müssen jeweils als zusammenhängende Einheit ausgeführt werden. Genau hier setzt der Mutex an. Der Bereich zwischen LOCK und UNLOCK stellt sicher, dass immer nur ein Thread gleichzeitig eine Stack-Operation ausführt.
Das #define USE_MUTEX 1 aktiviert den Mutex und es werden echte mtx_lock- und mtx_unlock-Aufrufe ausgeführt. Die erwartete Ausgabe ist:
USE_MUTEX=1 top=42
Ist USE_MUTEX auf 0 gesetzt, sind diese Makros leer und haben keine Wirkung. In diesem Fall ist der Endwert von top nicht mehr verlässlich und weicht häufig vom erwarteten Wert ab.
USE_MUTEX=0 top=16
Inkonsistenter Zustand
Vergisst man mtx_unlock() oder zerstört einen Mutex, während er noch gesperrt ist, entsteht undefiniertes Verhalten. Deshalb muss der Mutex in jedem Ausführungspfad wieder freigegeben werden, auch bei vorzeitigem Rücksprung oder nach Fehlern. Außerdem sollten kritische Abschnitte möglichst kurz bleiben, da ein gehaltener Mutex andere Threads blockiert und die Parallelität reduziert.
Nicht-blockierender Lock-Versuch
Neben dem blockierenden mtx_lock() stellt die Thread-API mit mtx_trylock() eine nicht-blockierende Variante bereit.
(Quelle: ISO/IEC 9899:2024, § 7.28.4.7 The mtx_trylock function)
int mtx_trylock(mtx_t *mtx);
mtx_trylock() versucht, den Mutex zu sperren. Ist der Mutex bereits durch einen anderen Thread belegt, kehrt die Funktion sofort zurück und blockiert nicht. Der Rückgabewert ist thrd_success, wenn der Mutex erfolgreich gesperrt wurde, andernfalls thrd_busy.
Diese Funktion eignet sich für Situationen, in denen ein Thread alternative Arbeit erledigen kann, statt zu warten. Sie wird häufig in Polling- oder Event-Loops verwendet, sollte aber mit Bedacht eingesetzt werden, da wiederholte Try-Lock-Versuche zu unnötiger CPU-Last führen können.
Mutexe und das Memory Model: acquire/release im Stack-Beispiel
Ein Mutex verhindert nicht nur, dass zwei Threads gleichzeitig denselben Code ausführen. Er definiert auch, welche Speicheränderungen ein Thread sehen darf, wenn er einen kritischen Abschnitt betritt. Diese Wirkung ist im C-Memory-Model als acquire/release-Semantik festgelegt.
Im Stack-Beispiel ist das entscheidend, weil eine Stack-Operation aus mehreren Speicherzugriffen besteht: Lesen und Schreiben von top sowie Zugriff auf das Array data. Diese Zugriffe müssen nicht nur exklusiv, sondern auch in einer wohldefinierten Reihenfolge sichtbar sein.
Wenn ein Thread eine Stack-Operation beendet und mtx_unlock() aufruft, hat dieser Unlock release-Semantik. Das bedeutet: Alle Änderungen an s.top und s.data, die vor dem mtx_unlock() erfolgt sind, gelten als abgeschlossen und dürfen nicht hinter das Unlock verschoben werden. Sie sind damit für andere Threads sichtbar, die den Mutex später erwerben.
- Im Stack bedeutet das: Ein vollständig ausgeführtes
pushhinterlässt immer einen konsistenten Stack-Zustand, bevor ein anderer Thread darauf zugreifen kann.
Wenn ein anderer Thread anschließend mtx_lock() aufruft, hat dieser Lock acquire-Semantik. Der Thread darf nach dem Lock keine veralteten Werte sehen. Alle Speicheränderungen, die vor dem zugehörigen Unlock eines anderen Threads erfolgt sind, müssen nun sichtbar sein.
- Für den Stack heißt das: Ein Thread, der den Mutex erwirbt, sieht garantiert den aktuellen Wert von
topund die dazugehörigen Daten im Array. Er arbeitet niemals in einem halbfertigen oder inkonsistenten Zustand.
Zwischen mtx_unlock() in einem Thread und dem darauffolgenden mtx_lock() in einem anderen Thread entsteht eine happens-before-Beziehung. Diese Beziehung stellt sicher, dass:
- jede abgeschlossene Stack-Operation vollständig sichtbar ist
- keine Speicherzugriffe aus einer Operation in die nächste hineinragen
- die Invariante des Stacks erhalten bleibt
Ohne diese Beziehung könnten Änderungen an top sichtbar werden, bevor die zugehörigen Daten geschrieben sind, oder umgekehrt. Der Stack wäre formal zerstört, auch wenn keine zwei Threads exakt gleichzeitig schreiben.
Im Stack-Beispiel schützt der Mutex nicht nur vor parallelem Zugriff. Er garantiert zusätzlich, dass alle Threads dieselbe zeitliche Sicht* auf den Stack haben. Jeder Thread sieht den Stack immer so, als wären alle vorherigen Operationen vollständig abgeschlossen.
Ohne Mutex wäre selbst bei scheinbar korrekter Reihenfolge im Code nicht garantiert, dass ein Thread die aktuellen Werte von top und data sieht. Der Fehler läge dann nicht im Algorithmus, sondern im fehlenden Synchronisationsversprechen.
In der Konsequenz macht der Mutex aus mehreren einzelnen Speicherzugriffen eine logisch abgeschlossene Operation mit klarer Sichtbarkeitsgarantie. Erst dadurch wird der Stack in einem nebenläufigen Programm überhaupt korrekt nutzbar.
Rekursive Mutexe
Ein einfacher Mutex vom Typ mtx_plain darf von einem Thread nur einmal gleichzeitig gesperrt werden. Versucht derselbe Thread, ihn erneut zu sperren, ist das Verhalten undefiniert. Diese Einschränkung ist bewusst gewählt und passt zu der üblichen Annahme, dass ein kritischer Abschnitt klar abgegrenzt ist und nur einmal betreten wird.
In manchen Programmen ist diese Annahme jedoch nicht erfüllt. Das tritt zum Beispiel bei rekursiven Funktionsaufrufen oder bei tief verschachtelten Aufrufketten auf, wenn mehrere Funktionen denselben Mutex benötigen, ohne voneinander zu wissen. In solchen Fällen würde ein einfacher Mutex zu einer Selbstblockierung führen.
Rekursive Mutexe (mtx_recursive) erlauben es einem Thread, denselben Mutex mehrfach zu sperren. Der Mutex merkt sich, wie oft der besitzende Thread ihn erworben hat, und wird erst freigegeben, wenn die entsprechende Anzahl an Entsperrungen erfolgt ist. Im Kern sieht das so aus:
mtx_t lock;
mtx_init(&lock, mtx_recursive);
void inner() {
mtx_lock(&lock);
// Nutzt dieselbe geschützte Ressource
mtx_unlock(&lock);
}
void outer() {
mtx_lock(&lock);
// Irgendwas
inner(); // sperrt denselben Mutex nochmal, aber erlaubt bei mtx_recursive
mtx_unlock(&lock);
}
Bei mtx_plain() wäre das zweite mtx_lock(&lock) im selben Thread problematisch. Bei mtx_recursive() klappt es, aber wichtig ist, es genauso oft zu unlocken wie zu locken.
Rekursive Mutexe sollten mit Bedacht eingesetzt werden, denn oft sind sie ein Hinweis darauf, dass kritische Abschnitte zu groß oder ungünstig geschnitten sind. In vielen Fällen ist es robuster, die Synchronisation auf eine äußere Ebene zu verlagern und innere Funktionen unter der Annahme auszuführen, dass der Mutex bereits gehalten wird.
Zeitgesteuerte Mutexe
Ein normaler Mutex blockiert einen Thread unbegrenzt, bis er freigegeben wird. In vielen Situationen ist dieses Verhalten erwünscht und unproblematisch, etwa wenn kritische Abschnitte kurz sind und kein Deadlock entstehen kann.
Es gibt jedoch Fälle, in denen ein Thread nicht unbegrenzt warten soll. Dazu gehören Programme, die auf Zeitvorgaben reagieren müssen, oder Systeme, in denen ein blockierter Thread als Fehler betrachtet wird. Für solche Situationen gibt es zeitgesteuerte Mutexe.
Ein zeitgesteuerter Mutex erlaubt es, den Versuch des Sperrens nach einer vorgegebenen Zeit abzubrechen. Der Thread erhält dann eine Rückmeldung, dass der Mutex nicht erworben werden konnte, und kann entsprechend reagieren. Das ändert nichts an der gegenseitigen Ausschlusswirkung des Mutex, sondern nur am Verhalten beim Warten. Im Kern sieht das so aus:
mtx_t lock;
mtx_init(&lock, mtx_timed);
struct timespec deadline = /* "jetzt" + timeout */;
int rc = mtx_timedlock(&lock, &deadline);
if (rc == thrd_success) {
// kritischer Abschnitt
mtx_unlock(&lock);
} else if (rc == thrd_timedout) {
// nicht bekommen -> alternativ handeln (z.B. später erneut versuchen)
} else {
// Fehlerfall behandeln
}
Der Rückgabewert von mtx_timedlock() gibt an, wie der Sperrversuch ausgegangen ist.
(Quelle: ISO/IEC 9899:2024, § 7.28.4.5 The mtx_timedlock function)
Der Code muss deshalb einen Pfad für »Mutex nicht bekommen« haben. Typische Konstanten, auf die geprüft wird, sind:
-
thrd_success: Der Mutex wurde erfolgreich gesperrt. Der Thread befindet sich im kritischen Abschnitt und muss den Mutex später freigeben. -
thrd_timedout: Die Frist wurde erreicht, bevor der Mutex verfügbar war. Der Mutex bleibt unverändert gesperrt. Der Thread kann alternative Aktionen ausführen, erneut versuchen oder abbrechen. -
thrd_error: Ein Fehler ist aufgetreten, etwa durch einen ungültigen Mutex oder eine fehlerhafte Zeitangabe.
deadline ist ein absoluter Zeitpunkt und keine Wartezeit. Damit unterscheidet sich die Funktion von APIs, die eine relative Dauer erwarten. Eine Angabe wie »50 ms warten« ist hier nicht direkt zulässig. Stattdessen ermittelt der Aufrufer zuerst den aktuellen Zeitpunkt und addiert die gewünschte Wartezeit. Das Ergebnis ist die Frist und gibt an, bis wann der Mutex spätestens erworben sein muss. Wird dieser Zeitpunkt erreicht oder überschritten, beendet die Funktion den Sperrversuch.
Zeitgesteuerte Mutexe erhöhen die Kontrolle über den Ablauf eines Programms, machen den Code aber auch komplexer. Jeder Sperrversuch kann scheitern und muss explizit behandelt werden. Deshalb sollten sie nur eingesetzt werden, wenn ein unbegrenztes Blockieren tatsächlich ein Problem darstellt.