Die Synchronisation von Prozessen ist ein schwieriges Teilgebiet von Betriebssystemen. Es gibt mehrere Varianten wie man mit einem **kritischen Abschnitt** umgehen kann. Jede Variante hat ihre Vor- und Nachteile. Das Thema Prozesssynchronisation werde ich aufgrund der Komplexität in drei Artikel aufteilen.

### Das Problem
Angenommen, in einem Rechnersystem finden in unregelmäßigen Abständen Ereignisse statt, über deren Häufigkeit Buch geführt werden soll. Ein Thread namens "Beobachter" zählt immer dann eine Variable Zähler hoch, wenn ein Ereignis stattgefunden hat. Ein zweiter Thread namens "Berichterstatter" druckt hin und wieder den Zählerstand auf eine Konsole aus und setzt die Variable Zähler auf Null zurück. Beide Threads existieren für immer.

```
Process Beobachter;
start
    do
        beobachte Ereignis;
        zähler = zähler + 1;
    until false
end;

Process Berichterstatter;
start
    do
        println(zähler)
        zähler = 0;
    until false
end;
```

Die Variable Zähler liegt in dem gemeinsamen Datensegment der Threads, auf den sie lesend und schreibend zugreifen können. Sie wird anfangs auf null gesetzt.

Man sollte meinen, dass zu jedem Zeitpunkt die Summe aller ausgedruckten Zählerstände zusammen mit dem aktuellen Wert von Zähler die Anzahl aller Ereignisse angibt, die bisher stattgefunden haben. Das stimmt aber nicht! Denn die beiden Threads laufen parallel ab, und dadurch kann es zum Beispiel zu folgender Ausführungsreihenfolge der Anweisungen kommen: Wenn der Berichterstatter gerade den aktuellen Zählerstand ausgedruckt hat und in diesem Moment wegen Ablauf seiner Zeitscheibe unterbrochen wird, könnte der Beobachter rechnend werden.

Angenommen, jetzt treten viele Ereignisse ein, und die Variable Zähler wird entsprechend hochgezählt. Sobaldder Berichterstatter wieder rechnend wird, setzt er als erstes den Zähler auf null, und alle soeben aufgetretenen Ereignisse sind verloren.

Dieser Fehler hängt nicht davon ab, dass wir nur über eine CPU verfügen; er kann ebenso auftreten, wenn die Threads auf verschiedenen Prozessoren mit unbekannten Geschwindigkeiten ablaufen. Hier liegen sogenannte **Wettkampfbedingungen (race conditions)** vor; welcher Thread als erster ein bestimmtes Ziel erreicht, ist nicht vorhersehbar.
Die Fehlerursache liegt vielmehr darin, dass die beiden Anweisungen

```
println(zähler)
    zähler := 0
```

im Programm des Berichterstatters einen **kritischen Abschnitt (critical section)** bilden, der keine Unterbrechung durch den Beobachter verträgt. Ein kritischer Abschnitt ist ein Abschnitt im Programm, in dem

* gemeinsame Ressource wie z. B. Variable und Datenstrukturen benutzt werden
* auf die mehrere Threads oder Prozesse lesend und schreibend zugreifen,so dass **race condition** entstehen kann

Man muss die beiden Threads irgendwie **synchronisieren**,um zu verhindern, dass beide zur gleichen Zeit in ihren kritischen Abschnitt eintreten. Also soll die Synchronisation den **exklusiven Zugriff auf den kritischen Abschnitt garantieren**.

### switch : Der Schalter
Eine Möglichkeit besteht darin, eine **Synchronisationsvariable [switch]** zu verwenden, die wie ein Schalter den Zugang zu den kritischen Abschnitten regelt. Hat sie den Wert 0, so ist der Beobachter an der Reihe, beim Wert 1 darf der Berichterstatter rechnen:

```
Process Beobachter;
start
    do
        while (switch = 1) do no-op;
        
        /* Beginn kritischer Abschnitt */
        beobachte Ereignis;
        zähler := zähler + 1;
        /* Ende kritischer Abschnitt */
        
        switch = 1;
    until false;
end;

Process Berichterstatter;
start
    do
        while (switch = 0) do no-op;
        
        /* Beginn kritischer Abschnitt */
        println(zähler)
        zähler := 0;
        /* Ende kritischer Abschnitt */
        
        switch = 0;
    until false;
end;
```

Dabei steht **no-op** für no operation; der Thread Beobachter bleibt also in der while-Schleife und tut nichts, bis die Bedingung falsch wird, das heißt, bis switch den Wert 0 erhält. Dann führt er seinen kritischen Abschnitt aus und setzt switch auf 1, damit der Berichterstatter in seinen kritischen Abschnitteintreten kann.

Allerdings hat diese switch-Variante zwei Nachteile:

* Beide Threads verbrauchen wertvolle CPU-Zeit, während sie in ihren while-Schleifen warten. Ein solches **geschäftiges Warten (busy waiting)** sollte vermieden werden

* Die beiden Threads können nur abwechselnd in ihre kritischen Abschnitte eintreten. Wenn einer von ihnen innerhalb des kritischen Abschnitts beendet werden sollte, kann der andere nie wieder den kritischen Abschnitt betreten.

Quelle
https://web.cs.wpi.edu/~cs3013/c07/lectures/Section06-Sync.pdf [letzter Zugriff: 23.11.2019, 19:31]