Fork System Call Linux

Der Fork -Systemaufruf wird verwendet, um neue Prozesse zu erstellen. Der neu erstellte Prozess ist der Kinderprozess. Der Prozess, der Fork bezeichnet und einen neuen Prozess erstellt, ist der übergeordnete Prozess. Die Kinder- und Elternprozesse werden gleichzeitig ausgeführt.

Aber die Kinder- und Elternprozesse befinden sich auf verschiedenen Speicherräumen. Diese Speicherplätze haben den gleichen Inhalt und jeder Fall, der von einem Prozess ausgeführt wird, wirkt sich nicht auf den anderen Prozess aus.

Wenn die Kinderprozesse erstellt werden; Jetzt haben beide Prozesse denselben Programmzähler (PC), sodass beide Prozesse auf denselben nächsten Anweisungen verweisen. Die vom übergeordneten Prozess geöffneten Dateien sind für den untergedreifenden Prozess gleich.

Der untergeordnete Prozess ist genau der gleiche wie sein Elternteil, aber es gibt einen Unterschied in den Prozessen -IDs:

1. Die Prozess -ID des Kinderprozesses ist eine eindeutige Prozess -ID, die sich von den IDs aller anderen vorhandenen Prozesse unterscheidet.
2. Die übergeordnete Prozess -ID ist die gleiche wie die der Prozess -ID des Elternteils des Kindes.

Eigenschaften des Kinderprozesses

Im Folgenden finden Sie einige der Eigenschaften, die ein Kinderprozess besitzt:

1. Die CPU -Zähler und die Ressourcennutzungen werden so initialisiert, dass sie auf Null zurückgesetzt werden.
2. Wenn der übergeordnete Prozess beendet wird, erhalten untergeordnete Prozesse kein Signal, da das Attribut pR_SET_PDEathsig in PrCtl () zurückgesetzt wird.
3. Der Thread zum Aufrufen von fork () erstellt den Kinderprozess. Die Adresse des Kinderprozesses ist also die gleiche wie die von Eltern.
4. Der Dateideskriptor des übergeordneten Prozesses wird vom untergeordneten Prozess vererbt. Beispiel. Der Dateideskriptor der übergeordneten Klasse bezieht sich daher auf denselben Dateideskriptor der untergeordneten Klasse.
5. Die Open Message -Warteschlangendeskriptoren des übergeordneten Prozesses werden vom Kinderprozess vererbt. Wenn beispielsweise ein Dateideskriptor eine Nachricht im übergeordneten Prozess enthält. Wir können also sagen, dass die Flag -Werte dieser Dateideskriptoren gleich sind.
6. Ähnlich offene Verzeichnisströme werden durch die Kinderprozesse vererbt.
7. Der Standard -Timer -Slack -Wert der Kinderklasse entspricht dem aktuellen Timer -Slack -Wert der übergeordneten Klasse.

Eigenschaften, die nicht durch ein Kinderprozess geerbt werden

Im Folgenden sind einige der Eigenschaften aufgeführt, die nicht durch einen Kinderprozess geerbt werden:

1. Speicherschlösser
2. Das anhängige Signal einer Kinderklasse ist leer.
3. Prozessbezogene Datensatzschlösser (fcntl ())
4. Asynchrone E/A -Operationen und I/A -Inhalte.
5. Verzeichnisänderungsbenachrichtigungen.
6. Timer wie Alarm (), SetItimer () werden von der Kinderklasse nicht vererbt.

gabel () in c

Es gibt keine Argumente in fork () und die Rückkehrtyp von Fork () ist ganzzahlig. Sie müssen die folgenden Header -Dateien einfügen, wenn fork () verwendet wird:

#enthalten
#enthalten
#enthalten

Kann bei der Arbeit mit fork () für den Typ verwendet werden pid_t Für Prozesse ist IDs als PID_T in definiert in .

In der Header -Datei wird Fork () definiert, sodass Sie sie in Ihr Programm einbeziehen müssen, um fork () zu verwenden.

Der Rückgabetyp ist in und fork () aufruf definiert in . Daher müssen Sie beide in Ihr Programm einbeziehen, um fork () -Systemanrufe zu verwenden.

Syntax von Fork ()

Die Syntax von Fork () -Systemaufruf in Linux, Ubuntu, lautet wie folgt:

pid_t gabel (void);

In der Syntax ist der Rückgabetyp pid_t. Wenn der Kinderprozess erfolgreich erstellt wird.

Wenn ein Fehler vorliegt, wird -1 an den übergeordneten Prozess zurückgegeben und der untergeordnete Prozess nicht erstellt.

Es werden keine Argumente an Gabel übergeben ().

Beispiel 1: fork () anrufen ()

Betrachten Sie das folgende Beispiel, in dem wir den Fork () -Systemaufruf verwendet haben, um einen neuen Kinderprozess zu erstellen:

#enthalten
#enthalten
#enthalten
int main ()

Gabel();
printf ("verwenden fork () system call \ n");
Rückkehr 0;

AUSGANG:

sysads@linuxHint $ gcc Fork.C -o Gabel
sysads@linuxHint $ ./Gabel
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf

In diesem Programm haben wir fork () verwendet, damit ein neues Kinderprozess erstellt wird. Wenn der Kinderprozess erstellt wird, verweist sowohl der übergeordnete Prozess als auch der untergeordnete Prozess auf die nächste Anweisung (derselbe Programmzähler). Auf diese Weise werden die verbleibenden Anweisungen oder C -Anweisungen ausgeführt, die Gesamtzahl der Prozesszeiten, dh 2^N Zeiten, wobei n die Anzahl der Fork () -Systemanrufe ist.

Also, wenn der Fork () -Anruf einmal wie oben verwendet wird (2¹ = 2) Wir haben unsere Ausgabe 2 Mal.

Wenn der Fork () -Systemaufruf verwendet wird, sieht die interne Struktur aus wie:

Betrachten Sie den folgenden Fall, in dem die Fork () 4 -mal verwendet wird:

#enthalten
#enthalten
#enthalten
int main ()

Gabel();
Gabel();
Gabel();
Gabel();
printf ("verwenden fork () system call \ n");
Rückkehr 0;

Ausgang:

sysads@linuxHint $ gcc Fork.C -o Gabel
sysads@linuxHint $ ./Gabel
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
Verwenden von Fork () -Systemanruf
sysads@linuxHint $

Jetzt ist die Gesamtzahl der erstellten Prozesse 2⁴ = 16 und wir haben unsere Druckanweisung 16 Mal ausgeführt.

Beispiel 2: Tests, wenn Fork () erfolgreich war

Im folgenden Beispiel haben wir das Entscheidungskonstrukt verwendet, um den von Fork () zurückgegebenen Wert (int) zu testen. Und die entsprechenden Nachrichten werden angezeigt:

#enthalten
#enthalten
#enthalten
int main ()

pid_t p;
p = fork ();
if (p ==-1)

printf ("Es gibt einen Fehler beim Aufrufen von fork () \ n");

if (p == 0)

printf ("Wir sind im untergeordneten Prozess \ n");

anders

printf ("Wir sind im übergeordneten Prozess \ n");

Rückkehr 0;

AUSGANG:

sysads@linuxHint $ gcc Fork.C -o Gabel
sysads@linuxHint $ ./Gabel
Wir sind im Elternprozess
Wir sind im Kinderprozess

Im obigen Beispiel haben wir den Typ pid_t verwendet, der den Rückgabewert von Fork () speichert. fork () wird online genannt:

p = fork ();

Der von fork () zurückgegebene Ganzzahlwert wird also in P gespeichert und dann wird P mit der Überprüfung verglichen, ob unser Fork () -Aufruf erfolgreich war.

Wenn der Fork () -Anruf verwendet wird und das Kind erfolgreich erstellt wird, wird die ID des Kinderprozesses in den übergeordneten Prozess zurückgegeben und 0 wird an den Kinderprozess zurückgegeben.Die ID des Kinderprozesses im übergeordneten Prozess ist nicht die gleiche wie die ID des Kinderprozesses im Kinderprozess selbst. Im Kinderprozess beträgt die ID des Kinderprozesses 0.

Mit diesem Tutorial können Sie sehen, wie Sie mit dem Fork -Systemaufruf in Linux beginnen.