Ja schauen wir uns mal ein paar einfache Beispiele von solchen Mikrotransaktionen

praktisch an. Wir wollen es so tun, dass wir das immer mit einer, sagen wir mal,

funktional gleichen Implementierung eines kritischen Abschnitts im Vergleich setzen.

Ja also hier denn etwa so eine einfache Multiplikationsoperation, wo wir denn sagen,

okay die Veränderung, die multiplikative Veränderung dieser Variable, in deren

Adresse wir über REF hier bekommen, muss atomar geschehen. Ja, dann formulieren wir

es als kritischen Abschnitt. Wir würden dann halt sagen, Enter und Leave und dazwischen sind dann

alle andere gleichzeitig Prozesse, die über diese Variable REF gekoppelt sind, denn eben ausgesperrt,

sodass dann der Code in Zeile 5 dann eben sequenziell zur Ausführung kommt. Also diese

Berechnung, den auch wirklich sequenziell nur für einen Prozess zu einem Zeitpunkt denn durchgeführt

wird. Und dieses Enter und Leave ist jetzt unabhängig davon, ob wir jetzt ein Zimmer vor

dahinter verstecken oder ob wir eine Umlaufsperre halt haben, soll einfach tatsächlich diesen

wechselseitigen Ausschluss auf im Sinne von kritischen Abschnitten auf der Software-Ebene

dann zum Ausdruck bringen. Nun die weitere Maßnahme, die wir hier ergreifen müssen, ist,

und wir müssen natürlich dann halt dieses Datum mit einem entsprechenden Riegel schützen,

so wie wir das früher dann schon mal gemacht haben. Also es würde bedeuten, dass dann hier unser

Long-T eben ein spezieller, selbst geschaffener Typ eines solchen Long-Objektes ist, wo wir das

eigentliche Datum halt haben, aber dann halt eben mit bold als Attribut eben eine Abstraktion,

entweder für eine Schlossvariable, dann ist das Enter halt eine Umlaufsperre oder binäre Zimmer

vor, dann würde das Enter eben eine P-Operation repräsentieren oder eben ein Mutex, dann würde

das Enter halt eben so ein Mutex-Log dann halt repräsentieren. Und die Leave-Operation entsprechend

in Werst dazu. Wir müssen halt eben genau das Objekt, was wir schützen wollen, dem müssen wir

dann halt eben auch noch einen entsprechenden Schutzmechanismus beiseite stellen. Das ist

doch nicht nur der Algorithmus, sondern wir würden hier auch entsprechend das Datum, das Attribut

letztendlich, was hier durch diesen Reffzeiger adressiert wird, ein bisschen anders auslegen

müssen. So, die semantisch-equivalente Fassung als nebenläufiger Abschnitt. Also wenn wir jetzt sagen

würden, okay, wir wollen das mal als eine Transaktion, als eine Mikrotransaktion formulieren,

sieht dann hier so aus, wie es hier da steht. Da gehen wir hier im ersten Schritt halt in der

Zeile 17 ran, lesen den alten Wert, wir ziehen die Kopie von dem Integer, von dem langen Integer,

der halt über Reff adressiert ist. Dann machen wir im nächsten Schritt praktisch die Berechnung von

dem new, wo wir dann halt die Multiplikation durchführen. Auf Basis der alten Kopie, die wir

halt haben, wird eine Multiplikation durchgeführt. Dann haben wir in new den neu berechneten Wert und

genau dieser Wert, den versucht man jetzt atomar mit der CAS-Operation praktisch zu übernehmen,

den Wert global zu bestätigen. Man überprüft also, ob an Reff noch old steht und wenn ja,

dann wird new der Wert von dieser Berechnung zugewiesen und die Operation gelingt und wir

liefern den new zurück, was wir gerade berechnet haben. Und ansonsten scheitert, wenn die Operation

scheitert, müssen wir die Berechnung nochmal durchführen, weil wir in der Zwischenzeit eben

von erkannt haben, dass dann andere Ausgangswert steht. Naja, da muss eben dann diese erneut

durchgeführt werden und dann auf Basis des neuen Ausgangswerts diese Berechnung durch

geführt werden. Die Berechnung selbst, die wir machen hier, also die Operation der Funktionale,

der reine Funktionale Anteil, den wir halt haben, der wird also immer gleichzeitig durchgeführt.

Das heißt also, diese funktionale Berechnung, die durch diese Multiplimentierung vorgegeben

ist, ist ein nehmläufiger Abschnitt. Ja, wir gehen optimistisch ran. Wenn wir jetzt also hier

zehn gleichzeitig Prozesse haben, dann würden die alle zehnmal gleichzeitig praktisch diese

Berechnung durchführen, aber nur einer wird bestätigen können letztendlich. Der nämlich

noch erkennt, dass an dieser Speicherstelle der alte Wert denn letztendlich steht. Nur für dieses

CAS gilt der wechselseitige Ausschluss, nicht für die gesamte Muldoperation, wenn man so will.

Ein anderes Beispiel etwa, ein bisschen komplexer, wenn wir jetzt mal so eine einfache

Listenmanipulation nehmen, nehmen wir mal so eine Lifo-Liste etwa, also etwa so was wie ein Stack,

wo wir dann halt die Objekte nach dem Stack-Modell dann entsprechend verketten. Dann haben wir hier