Alle Tabs der Lerneinheit (Erklärung · Interaktiv verstehen · Praxis-Übung · Klausur-Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur, und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).
Teil 1·Erklärung
Diese Lerneinheit wurde für typische Bachelor-Klausuren konzipiert. So prüfen wir · Fehler entdeckt? Melde ihn uns oder markiere die fragliche Stelle direkt im Text oben.
Alle Tabs der Lerneinheit (Erklärung · Interaktiv verstehen · Praxis-Übung · Klausur-Quiz) als durchgehender Text. Ideal zum Wiederholen vor der Klausur, und für Suchmaschinen wie Google, Bing und KI-Suche (ChatGPT, Perplexity).
Zwei Threads erhöhen denselben Zähler gleichzeitig, am Ende fehlt eine Erhöhung. Wie kann das sein? Weil nebenläufige Prozesse, die auf gemeinsame Daten zugreifen, koordiniert werden müssen. Ohne Synchronisation entstehen Race Conditions. Die klassischen Werkzeuge dagegen sind Mutex und Semaphor.
Was du in der Klausur können musst:
Klausur-Tipp: Merke dir die Startwerte: leer = Puffergröße, voll = 0, mutex = 1. Und die Reihenfolge: erst den Zählsemaphor (leer bzw. voll), dann den Mutex, sonst riskierst du einen Deadlock.
Anmelden, um den Fortschritt zu speichern.
Nächster Schritt
Aktives Abrufen festigt Wissen schneller als nochmal lesen.
Zwei Threads erhöhen denselben Zähler gleichzeitig, am Ende fehlt eine Erhöhung. Wie kann das sein? Weil nebenläufige Prozesse, die auf gemeinsame Daten zugreifen, koordiniert werden müssen. Ohne Synchronisation entstehen Race Conditions. Die klassischen Werkzeuge dagegen sind Mutex und Semaphor.
Was du in der Klausur können musst:
Synchronisation koordiniert nebenläufige Prozesse beim Zugriff auf gemeinsame Ressourcen. Im kritischen Abschnitt darf immer nur einer sein (gegenseitiger Ausschluss), durchgesetzt mit Mutex oder Semaphor.
Eine Race Condition liegt vor, wenn das Ergebnis von der zeitlichen Reihenfolge der Zugriffe abhängt. Klassiker: zwei Threads führen jeweils ein nicht-atomares "lies, erhöhe, schreibe zurück" auf demselben Zähler aus. Lesen beide den alten Wert, geht eine Erhöhung verloren (Lost Update).
Der Codebereich, der gemeinsame Daten verändert, heißt kritischer Abschnitt. Die Lösung ist gegenseitiger Ausschluss (mutual exclusion): in diesem Abschnitt darf immer nur ein Thread gleichzeitig sein.
| Mutex | Semaphor | |
|---|---|---|
| Wert | binär (gesperrt / frei) | Zähler ≥ 0 |
| Besitzer | ja (nur der Sperrende entsperrt) | nein |
| Operationen | lock / unlock | P (down/wait) und V (up/signal) |
| Zweck | gegenseitiger Ausschluss | Ressourcen zählen, Reihenfolge |
Ein Semaphor (Dijkstra) ist ein Zähler mit zwei atomaren Operationen:
Ein Zählsemaphor verwaltet mehrere gleichartige Ressourcen; ein binärer Semaphor (0/1) wirkt wie ein einfaches Lock.
Das Standardmuster: ein Producer legt Elemente in einen beschränkten Puffer, ein Consumer entnimmt sie. Zwei Zählsemaphore koordinieren das:
Ist der Puffer voll (leer = 0), blockiert der Producer; ist er leer (voll = 0), blockiert der Consumer. Probier es aus:
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
Ein Deadlock (Verklemmung) entsteht, wenn Prozesse zyklisch aufeinander warten und keiner mehr weiterkommt. Nach Coffman müssen dafür alle vier Bedingungen gleichzeitig gelten:
Fehlt eine der vier Bedingungen, kann kein Deadlock auftreten. Darauf zielen Vermeidungsstrategien (z.B. immer alle Locks in derselben Reihenfolge anfordern, das bricht den Circular Wait).
Verwandt, aber anders: Starvation (Verhungern), wenn ein Prozess zwar nicht blockiert ist, aber durch unfaire Vergabe nie an die Reihe kommt.
1. Race Condition: das Ergebnis hängt von der Ausführungsreihenfolge ab, bei ungeschütztem Zugriff auf gemeinsame Daten.
2. Kritischer Abschnitt: nur ein Thread gleichzeitig (gegenseitiger Ausschluss).
3. Mutex = binäres Lock mit Besitzer; Semaphor = Zähler mit P (down) und V (up).
4. Zählsemaphor zählt verfügbare Ressourcen; bei 0 blockiert P, bis ein V kommt.
5. Producer-Consumer: Semaphore leer (freie Plätze) + voll (belegte) + Mutex für den Puffer.
6. Deadlock braucht alle vier Coffman-Bedingungen. Fehlt eine, kein Deadlock.
1. Mutex und Semaphor gleichsetzen. Ein Mutex ist binär und hat einen Besitzer (nur wer sperrt, entsperrt). Ein Semaphor ist ein Zähler ohne Besitzer, jeder kann V aufrufen.
2. Race Conditions für reproduzierbar halten. Sie sind nichtdeterministisch und treten nur manchmal auf, was die Fehlersuche so schwer macht.
3. P und V vertauschen oder vergessen. P (down) vor dem kritischen Abschnitt, V (up) danach. Fehlt das V, bleibt die Ressource für immer blockiert.
4. Beim Producer-Consumer die Reihenfolge verdrehen. Erst P(leer) bzw. P(voll), dann P(mutex). Sperrt man zuerst den Mutex und blockiert dann am Zählsemaphor, droht ein Deadlock.
5. Busy-Waiting (Spinlock) als Standard nehmen. Aktives Warten verschwendet CPU. Semaphore lassen den Prozess stattdessen blockieren und schlafen.
6. Deadlock und Starvation verwechseln. Deadlock: mehrere warten zyklisch, niemand kommt weiter. Starvation: einer wird durch unfaire Vergabe dauerhaft übergangen, das System läuft aber weiter.
Klicke Produce und Consume und beobachte die beiden Semaphore. Fülle den Puffer ganz, der Producer blockiert (leer = 0). Leere ihn ganz, der Consumer blockiert (voll = 0). Genau dieses Blockieren verhindert Zugriffe auf einen vollen bzw. leeren Puffer.
Interaktive Visualisierung
Interaktive Komponente: probiere sie im Topic-Player oben aus.
Klausur-Tipp: Merke dir die Startwerte: leer = Puffergröße, voll = 0, mutex = 1. Und die Reihenfolge: erst den Zählsemaphor (leer bzw. voll), dann den Mutex, sonst riskierst du einen Deadlock.
Klausurfragen mit Lösungen (6)
Antwort: ein Fehler, bei dem das Ergebnis von der zeitlichen Reihenfolge der Zugriffe auf gemeinsame Daten abhängt
Erklärung: Eine Race Condition liegt vor, wenn das Ergebnis davon abhängt, in welcher Reihenfolge nebenläufige Threads auf gemeinsame Daten zugreifen. Typisch ist der Lost Update bei nicht-atomarem Lesen-Ändern-Schreiben.
Antwort: nur ein Thread gleichzeitig (gegenseitiger Ausschluss)
Erklärung: Im kritischen Abschnitt (Zugriff auf gemeinsame Daten) muss gegenseitiger Ausschluss (mutual exclusion) gelten: höchstens ein Thread darf gleichzeitig drin sein. Das verhindert Race Conditions.
Antwort: sie verringert den Zähler; ist er 0, blockiert der Prozess, bis ein V kommt
Erklärung: P (down/wait) verringert den Semaphor-Zähler. Ist der Zähler bereits 0, blockiert der aufrufende Prozess, bis ein anderer mit V (up/signal) wieder hochzählt.
Zuordnungen:
Erklärung: Mutex = binäres Lock mit Besitzer, Semaphor = Zähler (P/V), Race Condition = reihenfolgeabhängiges Ergebnis, Deadlock = zyklische Verklemmung.
Typ: Zuordnung
Antwort: Wahr
Erklärung: Richtig. leer zählt die freien Plätze (anfangs alle, also Puffergröße), voll die belegten (anfangs 0). Der Producer macht P(leer) und V(voll), der Consumer P(voll) und V(leer).
Typ: Wahr/Falsch
Antwort: alle vier (Mutual Exclusion, Hold-and-Wait, No Preemption, Circular Wait)
Erklärung: Ein Deadlock erfordert alle vier Coffman-Bedingungen gleichzeitig. Bricht man eine (z.B. Circular Wait durch feste Lock-Reihenfolge), ist ein Deadlock unmöglich. Das ist die Grundlage der Deadlock-Vermeidung.
Klausurfragen mit Lösungen (6)
Antwort: ein Mutex ist binär und hat einen Besitzer (nur der Sperrende entsperrt); ein Semaphor ist ein Zähler ohne Besitzer
Erklärung: Der Mutex ist binär (gesperrt/frei) und besitzgebunden: nur der Thread, der gesperrt hat, darf entsperren. Ein Semaphor ist ein Zähler mit P/V, den jeder Thread hochzählen darf, geeignet zum Zählen von Ressourcen.
Antwort: sie erhöht den Zähler und weckt einen wartenden Prozess
Erklärung: V (up/signal) erhöht den Semaphor-Zähler um eins und weckt, falls vorhanden, einen an P blockierten Prozess. P und V sind die beiden atomaren Semaphor-Operationen.
Antwort: es verschwendet CPU-Zeit durch aktives Warten, statt den Prozess schlafen zu legen
Erklärung: Beim Busy-Waiting prüft der Thread in einer Schleife ständig die Bedingung und verbraucht dabei CPU, ohne Fortschritt. Semaphore lassen den Thread stattdessen blockieren (schlafen), was die CPU freigibt.
Lösungen pro Lücke:
Erklärung: Mutex = binäres Lock mit Besitzer. Semaphor-Operationen: P (down/wait) verringert und blockiert ggf., V (up/signal) erhöht und weckt.
Typ: Lückentext
Antwort: erst P(leer), dann P(mutex)
Erklärung: Erst den Zählsemaphor P(leer), dann P(mutex). Würde der Producer zuerst den Mutex sperren und dann an P(leer) blockieren, könnte der Consumer den Mutex nie bekommen, ein Deadlock.
Antwort: indem man alle Locks immer in derselben global festgelegten Reihenfolge anfordert
Erklärung: Fordern alle Threads ihre Locks in derselben festen Reihenfolge an, kann keine zyklische Wartekette entstehen (Circular Wait gebrochen). Damit fehlt eine der vier Coffman-Bedingungen und ein Deadlock ist ausgeschlossen.