Mein, mein liebe Leute willkommen zum nächsten Video zur Verlesungbetriebssysteme.

Was haben wir gemacht?

Im letzten Video haben wir uns kurz angeguckt, wie man so von der Idee her es schafft, so

eine Art Multitasking hinzukriegen und dass man so verschränkt verschiedene Prozeduren

parallel, naja so pseudo parallel abarbeiten zu können.

Wir werden uns das jetzt hier mal so ein bisschen allgemeiner angucken im Sinne von, ja wir

haben Routinen, wir haben eine Routine F, wir hatten eine Routine G und die sollten so verschränkt

ablaufen.

Ja in der Programmiersprachenwelt werden die Dinger dann typischerweise als Co-Routinen

bezeichnet.

Gucken wir uns die genauen Unterschiede mal an.

Also fangen wir mal mit den Routinen an oder Funktionen oder Unterprogrammen, nennt die

Dinger wie ihr wollt.

Was ist eine Routine?

Das ist letztendlich eine endliche Sequenz von Anweisungen, einfach ein Stückchen Programmcode.

Kennt ihr aus praktisch allen Programmiersprachen, da gibt es dann irgendwelche Anweisungen

und Vorschleifen und If-Bedingungen und so weiter.

Die stehen einfach der Reihe nach hintereinander weg und bilden dann eine Routine.

Die Routine ausgeführt wird dann von einem Routinenkontrollfluss, heißt das ist das

Ding was jetzt die Routine in Ausführung bringt.

Ihr könnt euch vorstellen, dass es dazwischen immer Relationen gibt.

Wir haben die Routinen und wir haben die Ausführungen davon.

Das heißt das ist immer so eine Schema-Instanz-Relation.

Das was ich in meinem Programm schreibe ist sozusagen so ein Muster, so eine Art Template,

wie so eine Funktion, so eine Routine abgearbeitet werden soll und der Kontrollfluss der macht

die eigentliche Abarbeitung dann.

Geschrieben, die eigentliche Funktion oder Routine wird mit kleinen Buchstaben so geschrieben,

die Ausführung dann mit entsprechenden Spitzenklammern außenrum.

Gut, da gibt es jetzt neben den typischen Anweisungen, irgendwie Zuweisungen, Rechenoperationen

und so weiter, gibt es in den Routinen diese zwei typischen Elementaroperationen, das Call

und das Return.

Ihr kennt das aus der ganz normalen Programmierung, dass man eine Funktion aufruft bzw. dass

eine Return Instruktion am Ende einer Funktion die Ausführung beendet.

Gut, das kann man jetzt so ein bisschen formaler sagen, wenn in dem Instruktionsstrom, also

bei der Ausführung einer Funktion in dem Kontrollfluss jetzt so ein Call G auftaucht.

Was macht das Call?

Das erzeugt jetzt eine neue Ausführung, so einen neuen Kontrollfluss, ein Kontrollfluss,

der jetzt das G abarbeiten soll und die Abarbeitung von dem F wird erstmal suspendiert.

Das F rechnet jetzt nicht weiter, aber das G wird aktiviert, also das G rechnet jetzt

weiter ab, typischerweise natürlich ab der ersten Anweisung.

Und was macht das Return?

Das Return beendet die Ausführung von G, wenn in dem Kontrollfluss von G das Red vorkommt.

Typischerweise zerstört ist dann auch die Ausführung von G, die brauchen wir ja nicht

mehr, das Unterprogramm ist abgearbeitet und es reaktiviert jetzt die Ausführung des Aufrufenden,

also die aufrufende Routine, die wird dann fortgesetzt, die wird sozusagen reaktiviert.

Wenn man sich das anguckt, dann ist das immer so ein, wie das so schön heißt, LiFo Prinzip.

Die Funktion, die ich als letztes aufgerufen habe, also hier in diesem Baum sozusagen

das Call ist das letzte, was ich aufgerufen habe, das ist das erste, was wieder terminiert.

Und umgekehrt die Funktion, die ich als erstes aufgerufen habe, das ist die, die als letztes

terminiert.