imported>SchlurcherBot: Bot: http → https

2025-06-10T20:16:05Z

Bot: http → https

Neue Seite

In [[Unixoides System|unixoiden Betriebssystemen]] ist '''fork''' der Name eines [[Systemaufruf]]s, anhand dessen der aufrufende [[Prozess (Informatik)|Prozess]] (Elternprozess) eine Kopie von sich selbst erzeugt, einen sog. Kindprozess. Der Kindprozess übernimmt dabei die [[Datensegment|Daten]], den [[Codesegment|Code]], den [[Befehlszähler]] und die [[Handle#Datei-Handle|Dateideskriptoren]] vom Elternprozess und erhält vom Kernel (wie der Elternprozess und jeder andere Prozess auch) eine eigene Prozessnummer, die [[Prozess ID|PID]] (engl. „''P''rocess ''ID''entifier“).
In der Folge verwaltet das Betriebssystem den Kindprozess als eigenständige Instanz des Programms und führt ihn unabhängig vom Elternprozess aus.

Ein Kindprozess arbeitet meistens nicht exakt wie der Elternprozess weiter, sondern wählt andere Codepfade (andere Anweisungen).

An dem Rückgabewert von fork() wird erkannt, in welchem Prozess man sich befindet. Liefert fork() eine 0 zurück, kennzeichnet dies den Kindprozess, im Elternprozess wird die PID des Kindes zurückgeliefert. Bei einem Fehler liefert fork() einen Wert kleiner 0 und kein Kindprozess wurde erzeugt.

== Beispiel ==
Das folgende Programm ist in der Programmiersprache [[C (Programmiersprache)|C]] geschrieben und soll zeigen, wie ein Fork funktioniert. Das Beispielprogramm zählt von 0 bis 9 und gibt den Wert des jeweiligen Prozesses und seine individuelle Prozess-ID aus.
<syntaxhighlight lang="c">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>

int main ()
{
int i, j;
pid_t pid;

pid = fork();

if (pid == 0)
{
/* Kindprozess
* wenn fork() eine 0 zurückgibt, befinden wir uns im Kindprozess
*/
for (j=0; j < 10; j++)
{
printf ("Kindprozess: %d (PID: %d)\n", j, getpid());
sleep (1);
}
exit (0);
}
else if (pid > 0)
{
/* Elternprozess
* Gibt fork() einen Wert größer 0 zurück, befinden wir uns im Elternprozess
* in pid steht die ID des Kindprozesses
* getpid() gibt die eigene PID zurück
*/
for (i=0; i < 10; i++)
{
printf ("Elternprozess: %d (PID: %d)\n", i, getpid());
sleep (1);
}
}
else
{
/* Wird ein negativer Wert zurückgegeben, ist ein Fehler aufgetreten */
fprintf (stderr, "Fehler");
exit (1);
}
return 0;
}
</syntaxhighlight>

Mögliche Ausgabe des Programms:
Kindprozess: 0 (PID: 11868)
Elternprozess: 0 (PID: 11867)
Kindprozess: 1 (PID: 11868)
Elternprozess: 1 (PID: 11867)
Kindprozess: 2 (PID: 11868)
Elternprozess: 2 (PID: 11867)
Kindprozess: 3 (PID: 11868)
Elternprozess: 3 (PID: 11867)
Kindprozess: 4 (PID: 11868)
Elternprozess: 4 (PID: 11867)
Kindprozess: 5 (PID: 11868)
Elternprozess: 5 (PID: 11867)
Kindprozess: 6 (PID: 11868)
Elternprozess: 6 (PID: 11867)
Kindprozess: 7 (PID: 11868)
Elternprozess: 7 (PID: 11867)
Kindprozess: 8 (PID: 11868)
Elternprozess: 8 (PID: 11867)
Kindprozess: 9 (PID: 11868)
Elternprozess: 9 (PID: 11867)
Die Reihenfolge der Ausgaben kann variieren, da das Betriebssystem aufgrund verschiedener Kriterien zur Laufzeit entscheidet, welcher Prozess wann und für wie lange auf dem Prozessor ausgeführt wird ([[Scheduling]]). Unter anderem spielen dabei die momentane Auslastung der Rechner-Ressourcen, konkurrierende Prozesse (System- wie Anwendungsprogramme), die bereits verbrauchte Rechenzeit oder erduldete Wartezeit eine Rolle. Aus diesen Angaben wird die Priorität eines jeden Prozesses immer wieder neu bewertet. Die ausgegebenen Prozess-IDs werden bei jedem Programm- und Forkaufruf neu vergeben und sind deshalb nur beispielhaft.

== Nutzung von Fork zum Starten anderer Programme ==
Fork wird auch genutzt, um andere Programme (also keine Kopien des aufrufenden Programms) zu starten. Hierzu ruft nach dem Fork einer der Prozesse (in der Regel der Kindprozess) einen entsprechenden Befehl (z. B. [[Exec (Unix)|execve]]) auf, wodurch der aufrufende Prozess durch das gewünschte Programm ersetzt wird. Ein Beispiel: der Benutzer hat eine [[Unix-Shell|Shell]] geöffnet und möchte sich mittels des Befehls <code>[[ls (Unix)|ls]]</code> den aktuellen Verzeichnisinhalt anzeigen lassen. Er tippt also
ls
ein. Daraufhin passiert (vereinfacht dargestellt) Folgendes:
# Die Shell ruft fork() auf und erzeugt dadurch wie oben beschrieben einen neuen Kindprozess (eine Kopie von sich selbst).
# Der neu erzeugte Kindprozess ruft nun den Befehl execve("/bin/ls") auf. Hierdurch wird der Kindprozess durch das Programm ls ersetzt.
# Der so neu erzeugte ls-Prozess (der immer noch ein Kind der Shell ist) wird ausgeführt.

Die Verwendung von fork() erlaubt es dem Kindprozess, vor dem Aufruf von execve() seine [[Datei-Handle|Dateideskriptoren]] anzupassen, um somit beispielsweise die Ein-Ausgabe ([[Standard-Datenströme|stdin, stdout, stderr]]) umzulenken.<ref name="Modern Operating Systems">Andrew S. Tanenbaum: ''Modern Operating Systems''. Second Edition. ISBN 0-13-092641-8, S. 75</ref>

== Siehe auch ==
* [[Forkbomb]]

== Weblinks ==
* [https://www.unixguide.net/unix/programming/1.1.1.shtml What does fork() do?]

== Einzelnachweise ==
<references />

[[Kategorie:Unix-Betriebssystemkomponente]]

Fork (Unix) - Versionsgeschichte

imported>SchlurcherBot: Bot: http → https