Zunächst jetzt eine kurze Einführung ins Monitorkonzept. Wir setzen uns mit dem Begriff

der gemeinsamen Variable auseinander und betrachten dabei eben auch eine gewisse Menge von Operationen,

die wohl definiert sind auf diese gemeinsame Variable und mit diesen Operationen, denn eben

die eigentlichen mit der Variable assozierten sinnvollen Aktionen, denn eben ausführbar sind.

Das ist der Monitor. Der Monitor wurde ursprünglich eben auch so begrifflich als kritischer Bereich,

Kritikerischen verstanden. Er besteht aus einer Menge von Prozeduren, die denn eben mit einer

gemeinsamen Variablen unterschiedlicher Komplexität assoziiert sind. Diese enge

Bindung zwischen den Prozeduren und dieser gemeinsamen Variablen ermöglicht es nachher

einem Kompilierer zu prüfen, ob bestimmte Operationen, die mit der Variablen jetzt

ausgeführt werden, denn überhaupt definiert sind, ob die überhaupt gültig sind und andererseits

aber eben auch sicherzustellen, dass für diese Operation der wechselseitige Ausschluss gilt.

Also es ist eine implizite Synchronisation, die bei der Durchführung der Operation auf diese

gemeinsame Variable, die durch den Monitor definiert ist, festgelegt ist. Der andere Aspekt ist die

Condition, Condition Variable kann man sagen, eine Variable, eine spezielle Variable, die an sich für

das Programm selbst, was diese Bedingungsvariable verwendet, gar keinen zugriffbaren Datum letztendlich

hat, sondern lediglich dazu dient, eben bestimmte Wartezustände von Prozessen anzuzeigen und zu

steuern und damit eben Prozesse, die sich innerhalb des Monitors befinden, zu signalisieren, warten

zu lassen darauf, dass eine bestimmte Bedingung eintrifft und Prozesse also entsprechend dann

eben doch fortzusetzen, also die Kontrolle praktisch über die Abläufe von Prozessen innerhalb

eines Monitors zu ermöglichen. Damit ist denn so ein Monitor eben ein bestimmtes Mittel zur

Synchronisation. Dieses Mittel wollen wir verstehen und wir wollen es auch durchaus unabhängig

bestimmter sprachlicher Merkmale durchführen, also das auf einer etwas allgemeineren generellen

Ebene betrachten. Hier insbesondere denn eben doch die unterschiedlichen Stile, also Arten von

Monitoren betrachten, sowohl wie der Hansen Monitor, Hor Monitor, ein Monitor wie er in der Sprache

Konkaren Pascal oder in der Sprache Mesa implementiert war. Da schauen wir uns denn diese

unterschiedlichen Implementierungsvarianten denn im Detail an, um denn die Unterschiede und auch

die Gemeinsamkeit ein bisschen herauszuarbeiten. Wir wollen aber schon noch sehen und behalten,

dass eben dieses Konzept Monitor der problemorientierten Programmiersprache zuzuordnen.

Ist es also ein Konzept, was sprachlich unterstützt ist, da auch den Ursprung hat, damit eben auch ein

Compiler im Wesentlichen zu sehen ist, der dann dafür Sorge trägt, dass die Operationen auf

ein Monitor in korrekter Art und Weise dann ausgeführt werden. Der Monitor, so kann man es

allgemein noch ausdrücken, ist eigentlich ein Instrument zur Überwachung und zwar von

interagierenden Prozessen. Die Prozesse belegen Betriebsmittel, sie fordern Betriebsmittel an

und die Idee des Monitors ist dann praktisch genau diese Vergabe, die Einplanung der Nutzung dieser

Ressourcen durch diese verschiedenen gleichzeitig Kobettenprozesse eben kontrollieren zu können.

Nach einer bestimmten Politik und die Politik definiert dann letztendlich die unterschiedliche

Art des Monitors, die wir denn betrachten werden. Das ist ein programmiersprachlicher Ansatz,

wie ich es schon erwähnte, sitzt also in der gesamten Hierarchie, Software-Hardware-Hierarchie

unseres Rechensystems ganz oben, also auf der Programmiersprachen-Ebene. Ursprünglich war

das eigentlich nur so ein klassenähnlicher synchronisierter Datentyp, der eingeführt worden

ist. Dann gab es eine Sprache wie Simula 67, die ja sozusagen Ursprung für viele klassenbasierte,

klassenorientierte Programmiersprachen galt. Auch da wurden schon Monitorkonzepte realisiert. Die

erste wirkliche Implementierung einer Sprache, die Monitore durchweg beinhaltet hatte, war

Kankaren Pascal. Danach gab es dann durchaus sehr unterschiedliche Ausführungen. Also wir blicken

hier auf viele Jahrzehnte Entwicklungsgeschichte zurück, wenn es um so etwas wie Monitore

denn letztendlich geht. Das ist eine grundlegende Technik für die Systemprogrammierung, wenn es

denn darum geht, gekoppelte Prozesse in koordinierter Art und Weise ablaufen lassen zu können. Es ist

aber eben auch eine Programmierkonvention und nicht nur einfach ein Programmiersprachenkonstrukt,

eine Konvention in dem Sinne, dass man natürlich eben auch monitorartig Prozesse synchronisieren

lassen kann in Sprachen, die grundsätzlich solche Monitoreigenschaften, wie auch Bedingungsvarianten,