c systems notebook

Condition-Variables (cnd_t) und Call-Once-Mechanismus

In nebenläufigen Programmen reicht ein Mutex oft nicht aus. Ein Mutex schützt Daten vor gleichzeitigem Zugriff, aber er beantwortet keine andere Frage: Wann darf ein Thread sinnvoll weiterarbeiten? Wenn ein Thread auf das Eintreten einer bestimmten Bedingung warten muss, hilft bloßes Locken und periodisches Prüfen nicht weiter. Solches Busy-Waiting kostet CPU Zeit und skaliert schlecht.

Condition-Variables lösen genau dieses Problem. Sie erlauben es einem Thread, zu schlafen, bis ein anderer Thread mitteilt, dass sich der Zustand geändert hat. Der wartende Thread verbraucht in dieser Zeit keine Rechenzeit.

Eine Condition-Variable wird mit cnd_init() initialisiert (Quelle: ISO/IEC 9899:2024, § 7.28.3.3 The cnd_init function) , mit cnd_wait() wartet man auf eine Signalisierung, mit cnd_signal() weckt man einen wartenden Thread auf (Quelle: ISO/IEC 9899:2024, § 7.28.3.4 The cnd_signal function) , und mit cnd_broadcast() weckt man alle wartenden Threads auf. (Quelle: ISO/IEC 9899:2024, § 7.28.3.1 The cnd_broadcast function) Nach Gebrauch wird die Condition-Variable mit cnd_destroy() aufgeräumt. (Quelle: ISO/IEC 9899:2024, § 7.28.3.2 The cnd_destroy function)

Condition-Variablen treten typischerweise dort auf, wo Wartesituationen entstehen, also wenn ein Thread auf die Aktion eines anderen Threads warten muss. Ein klassisches Beispiel ist das Produzenten-Konsumenten-Szenario. Genau dieses Muster wird im folgenden Beispiel umgesetzt:

  • Der Produzent erzeugt Daten und signalisiert deren Verfügbarkeit.
  • Der Konsument wartet, bis diese Daten bereitstehen, und verarbeitet sie anschließend.
  • Der gemeinsam genutzte Zustand besteht aus data und dem Flag data_ready.
  • Eine Condition-Variable funktioniert nicht allein, sondern immer in Verbindung mit einem Mutex. Der Mutex schützt den gemeinsam genutzten Zustand, die Condition-Variable synchronisiert das Warten auf dessen Änderung. Ohne Mutex ist eine Condition-Variable praktisch nutzlos. Daher schützt ein Mutex diesen Zustand.
  • Eine Condition-Variable koordiniert das Warten und Aufwecken.

Der Code enthält bewusst eine umfangreiche Fehlerprüfung. Jede relevante Funktion wird auf Erfolg geprüft, Rückgabewerte werden ausgewertet, und Ressourcen werden sauber freigegeben. Das verlängert den Code, ist aber in C normal und bei solider Programmierung nicht zu vermeiden.

#include <stdio.h>
#include <stdlib.h>
#include <threads.h>

mtx_t mutex;
cnd_t condition;
int data_ready = 0;
int data = 0;

int producer([[maybe_unused]] void *arg) {
    thrd_sleep(&(struct timespec){.tv_sec = 1}, nullptr);

    if (mtx_lock(&mutex) != thrd_success) {
        puts("Producer: Mutex-Lock fehlgeschlagen");
        return 1;
    }

    data = 42;
    data_ready = 1;

    if (cnd_signal(&condition) != thrd_success) {
        puts("Producer: Signal fehlgeschlagen");
        mtx_unlock(&mutex);
        return 1;
    }

    if (mtx_unlock(&mutex) != thrd_success) {
        puts("Producer: Mutex-Unlock fehlgeschlagen");
        return 1;
    }

    return 0;
}

int consumer([[maybe_unused]] void *arg) {
    if (mtx_lock(&mutex) != thrd_success) {
        puts("Consumer: Mutex-Lock fehlgeschlagen");
        return 1;
    }

    while (!data_ready) {
        if (cnd_wait(&condition, &mutex) != thrd_success) {
            puts("Consumer: Warten auf Condition fehlgeschlagen");
            mtx_unlock(&mutex);
            return 1;
        }
    }

    printf("Empfangene Daten: %d\n", data);

    if (mtx_unlock(&mutex) != thrd_success) {
        puts("Consumer: Mutex-Unlock fehlgeschlagen");
        return 1;
    }

    return 0;
}

int main() {
    if (mtx_init(&mutex, mtx_plain) != thrd_success) {
        puts("Mutex-Initialisierung fehlgeschlagen");
        return EXIT_FAILURE;
    }

    if (cnd_init(&condition) != thrd_success) {
        puts("Condition-Initialisierung fehlgeschlagen");
        mtx_destroy(&mutex);
        return EXIT_FAILURE;
    }

    thrd_t prod, cons;

    if (thrd_create(&cons, consumer, nullptr) != thrd_success) {
        puts("Consumer-Thread-Erstellung fehlgeschlagen");
        cnd_destroy(&condition);
        mtx_destroy(&mutex);
        return EXIT_FAILURE;
    }

    if (thrd_create(&prod, producer, nullptr) != thrd_success) {
        puts("Producer-Thread-Erstellung fehlgeschlagen");
        // Consumer läuft bereits, wir sollten auf ihn warten
        thrd_join(cons, nullptr);
        cnd_destroy(&condition);
        mtx_destroy(&mutex);
        return EXIT_FAILURE;
    }

    int cons_result, prod_result;

    if (thrd_join(cons, &cons_result) != thrd_success) {
        puts("Consumer-Join fehlgeschlagen");
    } else if (cons_result != 0) {
        printf("Consumer beendet mit Fehler: %d\n", cons_result);
    }

    if (thrd_join(prod, &prod_result) != thrd_success) {
        puts("Producer-Join fehlgeschlagen");
    } else if (prod_result != 0) {
        printf("Producer beendet mit Fehler: %d\n", prod_result);
    }

    cnd_destroy(&condition);
    mtx_destroy(&mutex);
}

Im main() werden zuerst Mutex und Condition-Variable initialisiert. Erst danach werden die Threads erzeugt. Schlägt einer dieser Schritte fehl, wird korrekt aufgeräumt.

Der Konsumenten-Thread startet typischerweise zuerst. Er sperrt den Mutex und prüft, ob Daten verfügbar sind. Solange das nicht der Fall ist, ruft er cnd_wait() auf:

while (!data_ready) {
    cnd_wait(&condition, &mutex);
}

Dieser Aufruf ist zentral:

  • Der Mutex muss beim Aufruf gehalten werden.
  • cnd_wait() gibt den Mutex atomar frei und versetzt den Thread in den Wartezustand.
  • Beim Aufwachen wird der Mutex automatisch erneut gesperrt.
  • Erst danach kehrt cnd_wait() zurück.

Diese Atomarität ist entscheidend. Ohne sie wären Race Conditions unvermeidlich.

Warum die while Schleife zwingend nötig ist: Die Bedingung wird nicht mit if, sondern mit while geprüft. Das ist kein Stilmittel, sondern notwendig.

Condition-Variables dürfen sogenannte spurious wakeups erzeugen. Ein Thread kann aufwachen, ohne dass ein anderes Thread tatsächlich signalisiert hat. Dieses Verhalten ist erlaubt und im C Standard ausdrücklich vorgesehen. Deshalb gilt eine feste Regel: Nach jedem Aufwachen muss die Bedingung erneut geprüft werden. Nur die Bedingung entscheidet, nicht das Signal.

Der Produzent simuliert zunächst Arbeit mit thrd_sleep(). Danach sperrt er den Mutex, ändert den gemeinsamen Zustand und setzt data_ready auf 1. Erst dann ruft er cnd_signal() auf.

Das Signal wird innerhalb des kritischen Abschnitts gesendet. Das ist wichtig. Wird cnd_signal() ohne gesperrten Mutex aufgerufen, kann es zu sogenannten Lost Wakeups kommen: Der Konsument ist noch nicht im Wartezustand, das Signal verpufft, und der Konsument schläft anschließend dauerhaft.

Formal ist das kein undefiniertes Verhalten, praktisch aber fast immer ein Fehler.

Es gibt zwei signalgebende Funktionen:

  • cnd_signal() weckt höchstens einen wartenden Thread auf.
  • cnd_broadcast() weckt alle wartenden Threads.

In diesem Beispiel reicht cnd_signal(), da es nur einen Konsumenten gibt. Bei mehreren Konsumenten, die alle auf dieselbe Bedingung warten, ist cnd_broadcast() oft sinnvoller. Welches verwendet wird, hängt vom Protokoll ab, nicht von der Condition-Variable selbst.

Call-Once-Mechanismus (call_once(), once_flag)

In vielen Multithread Programmen gibt es Daten oder Zustände, die genau einmal aufgebaut und initialisiert werden müssen, bevor sie von mehreren Threads benutzt werden können. Dabei ist nicht nur wichtig, dass die Initialisierung nicht doppelt läuft, sondern auch, dass alle Threads warten, bis sie vollständig abgeschlossen ist.

Typische Gründe und Beispiele für einmalige Initialisierung sind:

  • Hohe Kosten beim Aufbau: Datenstrukturen werden berechnet, sortiert oder validiert. Das mehrfach zu tun wäre unnötig teuer.

  • Gemeinsame, unveränderliche Daten: Nach der Initialisierung werden die Daten nur noch gelesen. Mehrere Threads können dann ohne weitere Synchronisation darauf zugreifen.

  • Abhängigkeiten zu externer Umgebung: Dateien, Konfigurationen, Geräte oder Systemressourcen müssen erst geöffnet oder abgefragt werden, bevor sie benutzt werden können.

  • Globale Registrierungen: Tabellen für Dispatch, Callbacks oder Handler werden einmal aufgebaut und danach nur noch ausgewertet.

  • Zentrale Infrastruktur: Logsysteme, Speicherpools oder Thread Pools müssen vor der Benutzung vollständig eingerichtet sein.

  • Korrekte Sichtbarkeit: Threads dürfen erst weiterlaufen, wenn alle Daten konsistent und vollständig sichtbar sind. Ein halbfertiger Zustand ist inakzeptabel.

In all diesen Fällen reicht es nicht aus, nur zu verhindern, dass mehrere Threads gleichzeitig initialisieren. Alle anderen Threads müssen zuverlässig erkennen, wann die Initialisierung abgeschlossen ist, und bis dahin blockieren.

Das beschriebene Problem muss man nicht selbst lösen. Die Thread-Bibliothek stellt dafür eine Funktion bereit, die genau diesen Fall abdeckt.

  • void call_once(once_flag *flag, void (*func)(void));

call_once() sorgt dafür, dass die übergebene Funktion exakt einmal ausgeführt wird. Erreicht ein Thread den Aufruf, während ein anderer Thread die Initialisierung bereits ausführt, blockiert er so lange, bis diese abgeschlossen ist. Erst danach kehrt der Aufruf zurück.

Hinweis: Seit C23 stehen once_flag, ONCE_FLAG_INIT und call_once() auch in <stdlib.h> zur Verfügung (nicht nur in <threads.h>). Das Ziel ist, dass call_once() auch dann nutzbar sein soll, wenn das Thread-Modul nicht bereitgestellt wird, also unabhängig davon, ob <threads.h> vorhanden ist. Selbst wenn der Compiler +__STDC_NO_THREADS__+ definiert und <threads.h> komplett fehlt, muss <stdlib.h> die call_once-Funktionalität bereitstellen. In Single-Threaded-Implementierungen wird call_once entsprechend einfacher implementiert (ohne echte Thread-Synchronisation).

Im folgenden Beispiel wird eine Lookup-Tabelle nicht statisch hinterlegt, sondern zur Laufzeit berechnet. Mehrere Threads greifen darauf zu, wobei call_once() sicherstellt, dass der Aufbau genau einmal erfolgt und alle Threads erst danach mit konsistenten Daten weiterarbeiten:

#include <stdio.h>
#include <math.h>
#include <threads.h>

constexpr int TABLE_SIZE = 256;
constexpr double TWO_PI = 6.28318530717958647692;

static once_flag sine_once = ONCE_FLAG_INIT;
static double sine_table[TABLE_SIZE];

static void build_sine_table() {
    puts("Sinustabelle wird aufgebaut...");

    for (int i = 0; i < TABLE_SIZE; i++) {
        sine_table[i] = sin((TWO_PI * i) / TABLE_SIZE);
    }
}

double sine_lookup(int index) {
    call_once(&sine_once, build_sine_table);

    // Tabellenzugriff und Wrap-around für Indizes außerhalb 0..255
    return sine_table[index & (TABLE_SIZE - 1)];
}

call_once() stellt sicher, dass die Funktion build_sine_table() exakt einmal ausgeführt wird, egal, wie viele Threads gleichzeitig sine_lookup() aufrufen.

Der once_flag ist ein spezieller Typ aus der C-Bibliothek. (Quelle: ISO/IEC 9899:2024, § 7.28.2.1 The call_once function) Er wird einmal mit ONCE_FLAG_INIT initialisiert und merkt sich danach intern, ob die Initialisierung bereits stattgefunden hat.

Bei mehreren gleichzeitigen Aufrufen passiert folgendes:

  1. Erster Thread erreicht call_once(), startet build_sine_table() und setzt den Flag intern auf »läuft gerade«.

  2. Wenn andere Threads während des Aufbaus ebenfalls call_once() erreichen, warten sie, bis die Initialisierung fertig ist.

  3. Sobald der erste Thread fertig ist, werden alle wartenden Threads freigegeben. Ab jetzt erkennt call_once() sofort, dass alles erledigt ist, und kehrt ohne Wartezeit zurück.

Dadurch sehen alle Threads immer eine vollständig initialisierte Tabelle – keine Race Conditions, keine halbfertigen Daten.

Hinweis: Eine naive Implementierung mit Mutex und atomaren Variablen** ist oft fehleranfällig. Die Funktion call_once() ist genau für solche Fälle gemacht.