Im Zusammenhang mit der Simaphor-Implementierung, die wir vorhin in der Skizze uns mal angeschaut haben,

da wurde auch erwähnt, dass praktisch eine Monitortechnik die Grundlage bilden könnte,

um Simafor zu implementieren oder dass man überhaupt geneigt sein könnte, eben Simafor

als Monitor zu implementieren. Und auf diesen Aspekt möchte ich noch mal hier zu sprechen kommen,

nämlich Simafor Monitor. Und nehmen wir mal einfach an, dass wir wieder unsere fiktive

Cancaran C++ Sprache halt hätten, wo man denn so ein Monitor so klassenbasiert hier in die Art

beschreiben könnte als Template, wo man sagt, okay, ist ein Monitor, welches Typ Monitor, ein

Signal and Urgent Weight Monitor, also ein Orsher Monitor, soll unsere Simafor Klasse

den ausmachen. Und da haben wir unseren Zähler für den Simafor drin und dann eine Bedingungsvariante

natürlich, um letztendlich die Blockade von Prozessen innerhalb des P's letztendlich herbeizuführen,

und dann natürlich auch die Deblockierung durchzuführen. Und dann kann man sich so ein

Simafor-Implementierung auf Basis solch einer monitorartigen Sprache dann so vorstellen,

hier haben wir den Konstruktor, da werden wir dann erstmal den Initialwert des Simafors

dann festlegen, wir wissen ja Binärer versus zählender Simafor, gerade bei den zählenden

Simaforen, wo man dann normalerweise natürlich dann halt höhere Initialwerte als Einsten vorlegt.

Wenn man einen binären Simafor haben möchte und den zum Schutz eines kritischen Abschnitts

verwenden würde, dann würde dieser Seatwert hier typischerweise 1 sein, Initial. Aber

die Folgen mäßig sagt man einfach, hier soll eine Null drinstehen, wenn man im Konstruktor

keine weitere Spezifikationen anbietet. Nun die wesentlichen Operationen sind jetzt hier

das Prolag, also entspricht unserer P-Operation, das Verhug entspricht in unserer V-Operation,

entsprechend, also analog zu den Implementierungen, die wir denn vorher durchgeführt hatten,

hier würde man den Zähler um eins erniedrigenden prüfen, ob man in den negativen Bereich kommt,

das heißt den Zustand erreicht hat, dass es klar ist, dass ein Prozess im P blockieren

muss und wenn ja, dann würde man auf der entsprechenden Bedingungsvariable dann halt

warten mit dem Free-Way und die inverse Operation hier, man zählt hoch, man prüft nach, ob denn

wenigstens ein Prozess blockiert wäre in dieser P-Operation und macht dann halt die Signaloperation

dazu. Nun, wenn wir uns an diese vorgehende Vorlesung zu den Monitoren dran erinnern,

dann wissen wir, dass innerhalb des Ways eben implizit der Monitor freigegeben wird,

sodass es natürlich dann einem Prozess, einem anderen Prozess möglich sein wird, diese

Verhoch-Oben-Methode denn auszuführen und damit dann halt einen im Prolag wartenden Prozess

mit einem Signal dann halt wieder freizustellen. Und die P-Operation jetzt für unseren Zimmer

vor, die würden wir, wenn wir das jetzt auf der C-Ebene dann betrachten, würden dann

einfach so abbilden können auf die entsprechenden Prolag- und Verhochmethoden, wie wir sie hier

sehen. Nun, wie ich schon sagte, das ist der Horscher Monitor, das hat eben unter anderem

auch damit zu tun, dass wir halt hier eine IF-Abfrage halt haben. Da wird denn immer nur

aufgrund der Signalisierung genau ein Prozess ausgewählt, der dann gestartet wird und der

Wechsel von dem signalisierenden Prozess hin zum designalisierten Prozess findet eben

sozusagen unteilbar stattführt, also zur sofortigen Wiederaufnahme des Prozesses, der

halt hier in diesem Prolag warten würde. So könnte man sich eine Implementierung des

des Zimmer vor primitiven Prolag, Verhoch- bzw. P&V halt eben auch vorstellen, wenn man

eine Sprache hat, die Monitor-Konzepte letztendlich verinnerlicht. Nun, dennoch ist so eine Herangehensweise

dann schon mit Bedacht durchzuführen, da gibt es so einige Herausforderungen, die man halt

beachten muss. Das fängt schon mal letztendlich damit an, dass wenn wir heute die Systemprogrammier-Sprachen

uns anschauen, die es so gibt, dann kennen die so typischerweise Monitore als Sprachkonstrukt,

so wie wir das halt kennengelernt haben in der Form nicht. Das gilt auch durchaus ein

Stück weit für Java. Mit den Sprachkonstrukten von Java kann man Monitore durchaus nachbilden.

Es gibt sowas wie das Synchronize, wo man den wechselseitigen Ausschluss auf der Methoden-

oder etwa Grundblock-Ebene herbeiführen kann. Wir können Prozesse warten lassen, also das

heißt mit der Wait-Operation, das Blockieren und dann die Notify-Operation, um genau einen

wartenden Prozess zu deblockieren oder Notify All, um alle den halt freizustellen. Also hier