Der Fork-Systemaufruf wird zum Erstellen eines neuen Prozesses in Linux- und Unix-Systemen verwendet, der als „Fork“ bezeichnet wird untergeordneter Prozess , der gleichzeitig mit dem Prozess ausgeführt wird, der den fork()-Aufruf durchführt (übergeordneter Prozess). Nachdem ein neuer untergeordneter Prozess erstellt wurde, führen beide Prozesse die nächste Anweisung aus, die auf den Systemaufruf fork() folgt.
Der untergeordnete Prozess verwendet denselben PC (Programmzähler), dieselben CPU-Register und dieselben geöffneten Dateien wie der übergeordnete Prozess. Es benötigt keine Parameter und gibt einen ganzzahligen Wert zurück.
Unten sind verschiedene Werte aufgeführt, die von fork() zurückgegeben werden.
- Negativer Wert : Die Erstellung eines untergeordneten Prozesses war nicht erfolgreich.
- Null : Zurück zum neu erstellten untergeordneten Prozess.
- Positiver Wert : An Eltern oder Anrufer zurückgegeben. Der Wert enthält die Prozess-ID des neu erstellten untergeordneten Prozesses.
Notiz: fork() ist eine Threading-basierte Funktion. Um die richtige Ausgabe zu erhalten, führen Sie das Programm auf einem lokalen System aus.
Bitte beachten Sie, dass die oben genannten Programme nicht in einer Windows-Umgebung kompiliert werden können.
Beispiel für fork() in C
C
govinda
#include> #include> #include> int> main()> {> > >// make two process which run same> >// program after this instruction> >pid_t p = fork();> >if>(p<0){> >perror>(>'fork fail'>);> >exit>(1);> >}> >printf>(>'Hello world!, process_id(pid) = %d
'>,getpid());> >return> 0;> }> |
>
>Ausgabe
Hello world!, process_id(pid) = 31 Hello world!, process_id(pid) = 32>
Beispiel 2: Berechnen Sie, wie oft „Hallo“ gedruckt wird.
C
#include> #include> #include> int> main()> {> >fork();> >fork();> >fork();> >printf>(>'hello
'>);> >return> 0;> }> |
>
>Ausgabe
hello hello hello hello hello hello hello hello>
Erläuterung
Die Häufigkeit, mit der „Hallo“ gedruckt wird, entspricht der Anzahl der erstellten Prozesse. Gesamtzahl der Prozesse = 2N, wobei n die Anzahl der Fork-Systemaufrufe ist. Hier ist also n = 3, 23= 8 Lassen Sie uns einige Beschriftungsnamen für die drei Zeilen eingeben:
fork (); // Line 1 fork (); // Line 2 fork (); // Line 3 L1 // There will be 1 child process / // created by line 1. L2 L2 // There will be 2 child processes / / // created by line 2 L3 L3 L3 L3 // There will be 4 child processes // created by line 3>
Es gibt also insgesamt acht Prozesse (neue untergeordnete Prozesse und einen ursprünglichen Prozess). Wenn wir die Beziehung zwischen den Prozessen als Baumhierarchie darstellen wollen, wäre das Folgendes: Der Hauptprozess: P0 Von der 1. Abzweigung erstellte Prozesse: P1 Von der 2. Abzweigung erstellte Prozesse: P2, P3 Von der 3. Abzweigung erstellte Prozesse: P4, P5, P6, P7
P0 / | P1 P4 P2 / P3 P6 P5 / P7>
Beispiel 3: Prognostizieren Sie die Ausgabe des folgenden Programms.
C
#include> #include> #include> #include> void> forkexample()> {> >pid_t p;> >p = fork();> >if>(p<0)> >{> >perror>(>'fork fail'>);> >exit>(1);> >}> >// child process because return value zero> >else> if> ( p == 0)> >printf>(>'Hello from Child!
'>);> > >// parent process because return value non-zero.> >else> >printf>(>'Hello from Parent!
'>);> }> int> main()> {> >forkexample();> >return> 0;> }> |
>
>Ausgabe
Hello from Parent! Hello from Child!>
Notiz: Im obigen Code wird ein untergeordneter Prozess erstellt. fork() gibt im untergeordneten Prozess 0 und im übergeordneten Prozess eine positive Ganzzahl zurück. Hier sind zwei Ausgaben möglich, da der übergeordnete Prozess und der untergeordnete Prozess gleichzeitig ausgeführt werden. Wir wissen also nicht, ob das Betriebssystem zunächst die Kontrolle an den übergeordneten Prozess oder den untergeordneten Prozess übergibt.
Übergeordneter Prozess und untergeordneter Prozess führen dasselbe Programm aus, aber das bedeutet nicht, dass sie identisch sind. Das Betriebssystem weist diesen beiden Prozessen unterschiedliche Daten und Zustände zu, und der Kontrollfluss dieser Prozesse kann unterschiedlich sein. Siehe nächstes Beispiel:
Beispiel 4: Prognostizieren Sie die Ausgabe des folgenden Programms.
C
Java-Scanner
#include> #include> #include> #include> > void> forkexample()> {> >int> x = 1;> >pid_t p = fork();> >if>(p<0){> >perror>(>'fork fail'>);> >exit>(1);> >}> >else> if> (p == 0)> >printf>(>'Child has x = %d
'>, ++x);> >else> >printf>(>'Parent has x = %d
'>, --x);> }> int> main()> {> >forkexample();> >return> 0;> }> |
>
>Ausgabe
Parent has x = 0 Child has x = 2>
oder
Ausgabe
Child has x = 2 Parent has x = 0>
Hier wirkt sich eine globale Variablenänderung in einem Prozess nicht auf zwei andere Prozesse aus, da die Daten/der Status der beiden Prozesse unterschiedlich sind. Außerdem laufen Eltern und Kind gleichzeitig, sodass zwei Ausgänge möglich sind.
fork() vs. exec()
Der Fork-Systemaufruf erstellt einen neuen Prozess. Der von fork() erstellte neue Prozess ist bis auf den zurückgegebenen Wert eine Kopie des aktuellen Prozesses. Andererseits ersetzt der Systemaufruf exec() den aktuellen Prozess durch ein neues Programm.
Probleme basierend auf C fork()
1. Ein Prozess führt den folgenden Code aus
C
for> (i = 0; i fork();> |
>
>
Die Gesamtzahl der erstellten untergeordneten Prozesse beträgt (GATE-CS-2008)
(Ein
(B) 2^n – 1
(C) 2^n
(D) 2^(n+1) – 1
Hier finden Sie eine Lösung.
json vom Java-Objekt
2. Betrachten Sie das folgende Codefragment:
C
if> (fork() == 0) {> >a = a + 5;> >printf>(>'%d, %d
'>, a, &a);> }> else> {> >a = a –5;> >printf>(>'%d, %d
'>, a, &a);> }> |
>
>
Seien u, v die vom übergeordneten Prozess ausgegebenen Werte und x, y die vom untergeordneten Prozess ausgegebenen Werte. Welche der folgenden Aussagen ist WAHR? (GATE-CS-2005)
(A) u = x + 10 und v = y
(B) u = x + 10 und v != y
(C) u + 10 = x und v = y
(D) u + 10 = x und v != y
Hier finden Sie eine Lösung.
3. Sagen Sie die Ausgabe des folgenden Programms voraus.
C
plsql
#include> #include> int> main()> > >fork();> >fork() && fork()> |
>
>
Hier finden Sie die Lösung
In Verbindung stehende Artikel :
- C-Programm zur Demonstration von fork() und pipe()
- Zombie- und Orphan-Prozesse in C
- fork() und damit erstellte speichergemeinsame S/W-Prozesse