So nun müssen wir uns noch anschauen was eben passiert wenn man so einen Prozess

dann tatsächlich startet, wie der also so abläuft, wie der ganze Lebenszyklus aussieht.

Und als erstes schauen uns mal die Prozesszustände an. Ja und ich erläutere die

Prozesszustände wie sie hier beschrieben sind jetzt gleich anhand der Grafik auf der

folgenden Seite. Also am Anfang wird ein Prozess neu erzeugt. Es werden dann die

ganzen Datenstrukturen dafür angelegt im Speicher und wenn das alles passiert ist

und er prinzipiell lauffähig wäre, dann wird er quasi zur Ausführung zugelassen

und gerät damit in den Zustand bereit. Und das Betriebssystem verwaltet eine

Liste von bereiten Prozessen, das sind also all die Prozesse, die potenziell

laufen könnten, wenn ein Prozessor zur Verfügung steht. Welcher der lauffähigen

Prozesse tatsächlich dran kommt und ich gehe jetzt mal von einem Rechner mit nur

einem Prozessor aus, auf dem zu einem Zeitpunkt immer nur ein Prozess laufen

kann, das ist von der Betrachtung her jetzt erst mal einfacher. Also welcher der

potenziell lauffähigen Prozesse tatsächlich dann den Prozessor zugeteilt

bekommt, muss im Betriebssystem entschieden werden, da gibt es

unterschiedliche Kriterien dafür und wir werden in der Systemprogrammierung 2 da

ein größeres Kapitel auch dazu haben, wie man solche Entscheidungen trifft.

Und die Funktion im Betriebssystem, die diese Entscheidung trifft, nennt man

Scheduler oder Einplaner auf Deutsch. Und dieser Scheduler entscheidet dann eben

welcher der potenziell lauffähigen Prozesse drankommen kann, das könnte zum

Beispiel einer sein, der die höchste Priorität hat und bringt ihn zur

Ausführung auf der CPU. Da läuft der Prozess dann und führt eben den

Programmcode aus und jetzt gibt es verschiedene Möglichkeiten. Die simpelste

ist, er ruft die Funktion exit auf und terminiert damit und geht den Zustand

beendet über und das war's. Eine andere sehr häufige Situation ist, dass der

Prozess irgendetwas macht, worauf er warten muss. Er liest zum Beispiel ein

Zeichen von der Tastatur und bis der Nutzer dann endlich die Taste gedrückt

hat, dauert es ja eine Weile und in der Zwischenzeit kann eigentlich der

Rechner was anderes machen. Das heißt, der Prozess wird vom Betriebssystem in

den Zustand blockiert überführt und er wartet dort darauf, dass eben das

Ereignis eintritt auf das er wartet. Und das nehmen wir mal an, er wartet also auf ein

Zeichen von der Tastatur in dem Moment, wo sie also ein Zeichen eingegeben haben,

ist der Grund für die Blockade weggefallen. Das Betriebssystem wird

dieses Zeichen entgegen nehmen und irgendwo in einen Speicherbereich

eintragen, in dem der Prozess es dann im Rahmen der GetCharacter-Funktion oder der

Read-Funktion lesen kann und der Prozess geht wieder in den Zustand bereit und

wenn das Scheduler ihn wieder dran nimmt, dann kann er das Zeichen verarbeiten, dass

er da gelesen hat. Das ist also so eigentlich eine sehr häufige Schleife,

die Prozesse nehmen. Warten auf irgendetwas, das Ereignis tritt ein, sie werden

wieder bereit, das Scheduler nimmt sie wieder dran, sie laufen wieder, sie führen

wieder irgendeine Operation aus, auf die sie warten müssen und so weiter.

Es könnte aber auch sein, dass ein Prozess einfach nur rechnet. Mein

klassisches Beispiel dafür ist, der Prozess soll Pi berechnen. Pi können

sie beliebig lange rechnen und da müssen sie auch keine eine Ausgabe machen,

da können sie einfach rechnen. So ein Prozess, der also immer nur Pi berechnet,

stört möglicherweise die Ausführung von anderen Prozessen, denn während ein

Prozess blockiert ist, kann man natürlich einen anderen der bereiten

Prozesse dran nehmen und den laufen lassen.

Aber wenn ein Prozess sich nicht blockiert, dann kommt keiner der anderen,

die hier vielleicht in der Warteschlange im Zustand bereit sind, überhaupt noch