Lernziele für heute

Rückblick & Einordnung

Bisher (VL6 HTTP, VL7 MQTT) ging es darum, wie Systeme miteinander reden. Heute schauen wir, was in einem Knoten passiert, wenn viele Dinge gleichzeitig laufen.

Teil A · Was ist ein Prozess?

Prozesstabelle & Prozessleitblock (PCB)

Das Betriebssystem verwaltet alle Prozesse in einer Prozesstabelle. Jeder Eintrag ist ein Prozessleitblock (Process Control Block, PCB).

Prozesszustände

Ein Prozess durchläuft im Laufe seines Lebens drei Hauptzustände:

Prozesse erzeugen — fork()

POSIX-Systeme erzeugen neue Prozesse mit dem Systemaufruf fork().

Sequentiell · nebenläufig · parallel

Teil B · Threads = Leichtgewichtprozesse

Prozess vs. Thread im Vergleich

POSIX-Threads (pthreads) in C

Header #include <pthread.h> · kompilieren mit gcc prog.c -lpthread

#include <pthread.h>
#include <stdio.h>

void* sag_hallo(void* arg) {
    printf("Hallo vom Thread!\n");
    return NULL;
}

int main(void) {
    pthread_t t;
    pthread_create(&t, NULL, sag_hallo, NULL); // Thread starten
    pthread_join(t, NULL);                      // auf Thread warten
    return 0;
}

Parallelisierungsmodelle

Wie verteilt man Arbeit auf mehrere Threads? Drei klassische Muster:

Teil C · Auflösung: counter++ ist NICHT atomar

Es sieht aus wie ein einziger Schritt. In Wirklichkeit sind es drei:

int counter = 0;        // gemeinsame Variable
...
counter++;             // NICHT atomar: laden, +1, schreiben

Interleaving — das „Lost Update"

Beide Threads wollen counter (Startwert 5) um 1 erhöhen — erwartet wären 7.

Race Condition — Definition

Kritischer Abschnitt

Die 4 Regeln für eine korrekte Lösung

Teil D · Naive Versuche (und warum sie scheitern)

Wir kennen jetzt die 4 Regeln. Was wäre die naheliegende erste Idee, um zwei Threads auseinanderzuhalten? Zwei Versuche — beide kippen.

while (flag);   // warten bis frei (flag==0)
flag = 1;       // belegen
... // kritischer Abschnitt
flag = 0;       // freigeben

Semaphor (Dijkstra, 1965)

DOWN(S) { S = S - 1; if (S < 0) blockieren; }   // Platz belegen, sonst warten
UP(S)   { S = S + 1; if (Warteschlange) einen wecken; } // Platz frei → nächsten wecken

Binärer Semaphor = Mutex

Mutex in C — die Denkfrage gelöst

#include <pthread.h>

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;

void* zaehle(void* arg) {
    for (int i = 0; i < 1000; i++) {
        pthread_mutex_lock(&lock);   // DOWN — Schlüssel nehmen
        counter++;                       // kritischer Abschnitt
        pthread_mutex_unlock(&lock); // UP — Schlüssel zurück
    }
    return NULL;
}

Deadlock — wenn sich zwei Threads gegenseitig einsperren

Es gibt zwei Sperren, A und B. Jeder Thread schnappt sich zuerst eine — und will dann die andere.

Producer-Consumer-Problem

Wir haben jetzt die Werkzeuge (Mutex, Semaphor) und kennen die Gefahr (Deadlock). Zeit für das berühmteste Übungs-Beispiel, das alles zusammenbringt — und das uns zu verteilten Systemen führt.

Bezug zu verteilten Systemen

🧠 Quiz

→ Klicke auf eine Antwort, um aufzulösen

Zusammenfassung

© 2026 HTW Berlin · Verteilte Systeme