Im ersten Teil der aktuellen Übung wollen wir uns mal anschauen, was Mutexes sind und

wie diese mit Bedingungsvariablen interagieren.

Unter einem Mutex versteht man ein Mittel, mit dem man gegenseitigen Ausschluss erreichen

kann.

Dies kann genutzt werden, um den Zugriff auf kritische Abschnitte zu koordinieren.

In diesem Beispiel wollen zwei Threads auf einen kritischen Abschnitt zugreifen und müssen

dafür zunächst einmal die Log-Operation aufrufen, um den kritischen Abschnitt zu betreten und

wenn sie den Abschnitt verlassen wollen, die Unlog-Operation.

In dem Beispiel ist zunächst Thread 1 dran und ruft die Log-Operation aus, um den Abschnitt

zu betreten.

Während er selbst in dem Abschnitt ist, kann Thread 2, der ebenfalls versucht, die Log-Operation

aufzurufen, nicht den Abschnitt betreten, sondern wird solange verzögert, bis Thread

1 die Unlog-Operation aufruft und damit den kritischen Abschnitt verlässt.

Ab dem Moment befindet sich Thread 2 in dem kritischen Abschnitt und besitzt das Log bzw.

das Mutex.

Und zwar solange, bis auch er wieder die Unlog-Operation aufruft.

Das bedeutet, genau ein Thread kann jeweils den Mutex sperren und damit den kritischen

Abschnitt betreten.

Nachdem wir nun grob wissen, was ein Mutex macht, wollen wir uns die Schnittstelle anschauen,

die uns zur Verfügung steht, um diese eben zu nutzen.

Dafür bietet POSSEX einmal die Pivot Mutex Schnittstelle an.

Mit dieser können wir Mutex erzeugen, sie sperren, wieder freigeben und schließlich

zerstören.

Um ein Mutex zu erzeugen, brauchen wir zunächst einmal ein Mutex-Objekt.

Dieses ist vom Typ Pivot Mutex T.

Sobald wir dieses haben, müssen wir es aber noch vor der ersten Nutzung initialisieren.

Dazu wird die Pivot Mutex Init-Funktion aufgerufen, die eben eine Referenz auf das Objekt als

erstes Argument bekommt.

Als zweites Argument kann man noch optionale Attribute angeben, mit denen das Verhalten

des Mutex noch weiter beeinflusst werden kann.

Zum Beispiel kann man hier bestimmen, dass das Mutex rekursiv betreten werden kann.

Das bedeutet, dass der Thread, der einmal die Log-Operation ausführt, sie erneut auf

dem Mutex ausführen kann, ohne es vorher freizugeben.

Die weiteren Attribute an Pivot Mutex Init sind für SP aber erstmal nicht weiter relevant.

Der Rückgabewert der Pivot Mutex Init-Funktion ist gleichermaßen ein Fehlerindikator als

auch der Fehlerwert selbst.

Möchte man nun also eine Fehlermeldung auf Basis der Erne ausgeben, muss man den Rückgabewert

erst in der Erne speichern, damit anschließend Funktionen wie P-Error aufgerufen werden

können.

Das Sperren und Freigeben des Mutex geschieht wieder mit einem Zeiger darauf.

Zum Sperren wird die Funktion Pivot Mutex Log aufgerufen und zum Wiederfreigeben die

Funktion Pivot Mutex Unlog.

Zwischen den Aufrufen an beiden Funktionen befindet man sich im kritischen Abschnitt,

der durch das jeweilige Mutex geschützt wird.

Sobald ein Mutex nicht weiter genutzt wird, kann man es auch wieder freigeben, das heißt

die Ressourcen wieder zurückgeben.

Dafür ruft man die Funktion Pivot Mutex Destroy auf, die als Argument wieder ein Zeiger auf

das Mutex erwartet.

Und auch hier gilt, wie bei Pivot Mutex Init, dass der Rückgabewert gleichermaßen ein Fehlerindikator

ist als auch der Fehlerwert selbst.