Ja, okay, der Monitor. Wir wollen uns in einem ersten Block erstmal die Eigenschaften, die mit

solchen Monitoren verbunden sind, anschauen und in einem zweiten Block auf bestimmte architektonische

Merkmale der unterschiedlichen Arten von Monitore eingehen. Okay, der Monitor, den kann man sich ganz

einfach als einen sogenannten synchronisierten abstrakten Datentypen vorstellen. Man hat also

hier grundlegende Eigenschaften eines sogenannten abstrakten Datentyps, den man im Monitor sieht,

wo denn die Zugriffsoperation auf diesen Datentyp eben implizit synchronisiert sind. Da haben wir

einerseits die sogenannte mehrseitige Synchronisation an der Monitorschnittstelle. Diese

Synchronisationsart hatten wir ja in der Vergangenheit schon kennengelernt und das bedeutet hier konkret

wechselseitig einen Ausschluss bei der Ausführung der an dieser Schnittstelle exportierten Prozeduren.

Dieser wechselseitige Ausschluss wird dann typischerweise sichergestellt, indem man so

Schlossvariablenkonzepte, Sperrverfahren darüber dann abwickelt oder eben vorzugsweise Simmaforum

halt nimmt. Die Simmaforum werden uns in der nächsten Vorlesung beschäftigen und die

Schlossvariablen in der übernächsten Vorlesung. Also wir gehen auf diese Techniken, wie man denn

den wechselseitigen Ausschluss denn implementiert schon noch ein und dann sieht man eben auch wie

die mehrseitige Synchronisation an so einer Monitorschnittstelle verwirklicht werden kann.

Dann haben wir innerhalb des Monitors noch die einseitige Synchronisation, denn nur den

wechselseitigen Ausschluss zu haben, das hilft in vielen Fällen nicht, nämlich genau in solchen

Fällen nicht, wo die Prozesse explizit interagieren müssen. Sie müssen sich Signale zustellen,

sie müssen kommunizieren und dazu dient eigentlich die Bedingungsvariable, mit der man denn eine

logische oder Bedingungs-Synchronisation durchführen kann. Da gibt es die zwei Basisoperationen,

die Operation Vade und Signal. Mit der Vade-Operation ist ein Prozess in der Lage, sich auf das

Eintreten eines bestimmten Ereignisses zu blockieren und im Zuge dieser Blockade, die er dann durchführt,

im implizit den Monitor freizugeben. Die Signalisierungsoperation zeigt dann praktisch

diesen Ereignisseintritt an und führt dann dazu, dass ein Prozess deblockiert wird. Wie viele

Prozesse jetzt deblockiert werden, ob es einer ist oder ob es dann praktisch alle Prozesse sind,

die auf dieses Ereignis warten, hängt dann nachher von der Art, von dem Typ des Monitors ab. Aber

dazu werden wir dann später nochmal weitere Dinge betrachten. Der Ereignisseintritt, den wir hier

haben, wird rein technisch gesehen durch ein Signal repräsentiert, also ein Prozess, der praktisch

so ein Ereignis auslöst, sendet ein Signal ab und dieses führt dann letztendlich oder bedeutet

denn die Aufhebung einer Wartbedingung für wenigstens einen anderen Prozess, der sich vorher einmal

in diesem Monitor befunden hatte. Und über diese Techniken der Bedingungsvariable sind denn die

Prozesse in der Lage, sich innerhalb eines Monitors denn explizit zu synchronisieren und

in die Aktion nochmal treten zu können, sich bestimmte Ereignisse dann sozusagen zuzustellen

und zum Ausdruck zu bringen, dass man auf bestimmte Ereignisse warten möchte. Das ist ein sprachgespitzter

Ansatz, wo wir normalerweise einen Übersetzer, einen Compiler als Grundlage haben, der dann halt

in der Lage ist, eben automatisch die Synchronisationsbefehle zu generieren. Das gilt für die

mehrseitige Synchronisation. Also wir müssen demzufolge diesen wechselseitigen Ausschluss

überhaupt gar nicht mehr sprachlich oder algorithmisch zum Ausdruck bringen. Wir

müssten letztendlich nur einen Typen verwenden, nämlich den Monitor als Datentyp verwenden und

dort halt ein Exemplar eines solchen Datentyps schaffen, dann bekommt man automatisch die

synchronisierten Operationen an der Monitorschnittstelle gebunden, geboten und den Code dafür, den generiert

der Compiler. Die einseitige Synchronisation, also die Dinge mit der Bedingungsvariable, die

Signals und die Weights, die man da hat, die muss man schon noch explizit codieren und hinschreiben,

weil das ja immer von bestimmten Zuständen abhängig ist, von bestimmten Berechnungen abhängig ist,

ob man, ob ein Prozess auf einen Eintritt eines Ereignisses warten muss oder nicht. Das kann ein

Compiler nicht sozusagen vorhersehen, es muss denn explizit codiert werden. So ein Monitor ist eine

Klasse, aber eben auch ein Modul oder man kann sagen, ist eine Klasse, die sich sehr stark auf ein

Modul bezieht. Beide Konzepte, Klasse wie auch Modul spielen hier eine Rolle. Die Merkmale, die man mit

Klassen und mit Modulen verbindet, die spiegeln sich typischerweise, so ein Monitor, den nimmt auch

wieder. Da haben wir nämlich einerseits die sogenannte Kapselung. Das heißt also, Daten, die von