Nun, im Anhang möchte ich noch ein paar ergänzende Informationen zu dieser Fiktion

Concurrency++ geben. Was wir zuvor gerade gesehen haben mit dem Beispiel des Ringpuffers. Wie der

denn praktisch dieser Puffer eben als monitorartiges Konstrukt denn formuliert worden ist. Wir hatten

da mit dem Template-Konstrukt von C++ eben so eine Art Klassenvorlage generiert. Womit man denn mit

solchen Klassenvorlagen mit solchen Templates eben in der Lage ist eben eine generische

Implementierung eines solchen Datenpuffers hier konkret anzugeben. Nun die für den monitorrelevanten

weiteren Spezifikation war den Monitor selbst als Vorlagenparameter, sodass man dann halt sagt,

dass diese Klasse eben als Monitor verstanden werden sollte. Man kann sich hier auch vorstellen,

dass man eine weitere Verfeinerung dieser Angabe macht mit monitorgleichname, wobei der Name

praktisch die Art des Monitors etwa sein könnte oder die Art der Signalisierung, die man mit diesem

Monitor denn verbindet. Denn wir wissen ja, dass dann sozusagen eben auch dieses when, was wir

gesehen haben, also im Wesentlichen all diese Sachen, die mit der Bedingungsvariable zu tun haben,

sich denn schon unterscheiden, in der Abhängigkeit davon, welche Art von Monitor man jetzt hier

benutzen möchte. Nun die Exemplare in dieser Klasse sind dann die eigentlichen Monitorobjekte,

die dann zur Verfügung gestellt werden, so im Sinne wie ganz normale Klassenobjekte. Die mit

Condition wurde dann eben eine Bedingungsvariable deklariert und damit letztendlich die Operatoren

wait und signal ermöglicht, um den praktisch eben Prozesse kontrolliert warten lassen zu können oder

eben auch eine Fortsetzung für Prozesse über Signal zu ermöglichen. Und das when war eben so

eine Kontrollstruktur im Endeffekt, um Prozesse bedingt warten zu lassen, führt normalerweise

immer eine Wait-Operation voran und in Abhängigkeit von der Verfeinerung des Monitors,

wo war denn so ein when denn ein while, wenn wir etwa so Single Continue Monitor oder Single

Return Monitor, den haben wir gar nicht betrachtet, aber so eine Art von Monitoren gibt es auch,

haben oder es ist ein if, wenn man Single Wait und Single Urgent Wait semantiken, denn hat,

wenn man also sicherstellen kann, dass zwischen diesen Signal und dem herauskommen aus dem Wait

eben kein anderer Prozess zwischenzeitlich in diesen Monitor eintreten kann. Aber letztendlich

unabhängig jetzt mal von solchen fiktiven Dingen, wie man sich denn vielleicht so eine RC++

vorstellen könnte, dass es als nebenläufige Sprache gilt, kann man natürlich dann durch

so eine Spracherweiterung in manchen Sprachen, gerade auch bei objektorientierten Sprachen,

eben durch andere Sprachkonzepte geben lassen. Zum Beispiel könnte man Vererbung einsetzen,

indem man den normalen Klaas Buffer halt hat, wo man denn eben von einer Monitorklasse erbt und

damit sich sozusagen diese Monitoreigenschaften zu eigen macht. Ähnlich kann es dann halt mit so

einer Conditionklasse sein, wo man sich dann einfach die Bedingungsvariablen dann halt gibt

und damit die Wait und Single Operation dann entsprechend verfügbar werden. Das geht relativ

einfach, sehr mal gleich sehen. Nur mit dem Wenn müssen wir dann halt dann schon irgendwie so

Tricks machen, die natürlich dann mit C-artigen Sprachen gar nicht so kompliziert sind, wie man

jetzt mal hier so sehen würde. Man würde dann sozusagen das Wenn einfach als ein Makro definieren

und dann in der Abhängigkeit von irgendeiner von einem globalen Schalter, der dann halt letztendlich

die Semantik des Monitors so ein bisschen zum Ausdruck bringen soll, denn definieren ob hätten

wir vor dann Wireless und damit dann letztendlich für möglicherweise für eine erneute Auswertung der

Wartebedingungen Sorge tragen kann. Nun diese neue Auswertung der Wartebedingungen kann denn

also im Fallen, wenn es Signal höchstens genau einen Prozess auswählt und der ausgewählte Prozess

unteilbar zu dem signalisierenden Prozess aufgenommen wird. Das sind dann komplizierte

Vorgänge, weil wir wissen ja, Single muss dazu führen, dass der laufende Prozess den Monitor

verlässt. Der muss dann automatisch impliziten Prozess auswählen und dieser ausgewählte Prozess

muss wieder aufgenommen werden können. Der muss also sozusagen direkt in den Monitor eintreten.

Das sind schon komplizierte Vorgänge, die jetzt innerhalb eines Systems ablaufen müssen. Deshalb

sind so eine Arten von Monitoren nicht weit verbreitet, obwohl sie an sich eine schöne,

sage mal, Eigenschaft eben besitzen hinsichtlich dieser des Zusammenspiels zwischen Signal und

To-Waite. Nun, wenn wir eine falsche Signalisierung haben, dann wissen wir eben, dass diese If-Variante

eben dazu führt, dass man potenzielle Programmierfehler eben nicht toleriert. Denn wenn dieses