Fork -Systemaufruf in c

Fork () -Systemaufruf wird verwendet, um untergeordnete Prozesse in einem C -Programm zu erstellen. Fork () wird verwendet, wenn in Ihrer Anwendung eine parallele Verarbeitung erforderlich ist. Die Fork () -Systemfunktion ist in den Headern definiert Systeme/Typen.H Und Unistd.H. In einem Programm, in dem Sie Fork verwenden, müssen Sie auch Wait () Systemanruf verwenden. Wait () Systemanruf wird verwendet, um im übergeordneten Prozess zu warten, bis der Kinderprozess fertig ist. Um einen Kinderprozess zu beenden, wird der Aufruf von Exit () -System im Kinderprozess verwendet. Die Wait () -Funktion ist im Header definiert sys/warte.H und die Funktion exit () ist im Header definiert stdlib.H.

Abb. 1: Basic Fork () Workflow

In diesem Artikel werde ich Ihnen zeigen, wie Sie den Fork () -Systemanruf verwenden, um untergeführte Prozesse in C zu erstellen. Also lasst uns anfangen.

Fork () Syntax und Rückgabewert:

Die Syntax der Fork () -Systemfunktion lautet wie folgt:

pid_t gabel (void);

Die Fork () -Systemfunktion akzeptiert kein Argument. Es gibt eine Ganzzahl des Typs zurück pid_t.

Bei Erfolg gibt Fork () die Haltung des Kinderprozesses zurück, der größer als 0 ist. Im Kinderprozess beträgt der Rückgabewert 0. Wenn Fork () fehlschlägt, gibt es -1 zurück.

Einfacher Fork () Beispiel:

Ein einfaches Fork () -Stile ist unten angegeben:

#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
int main (void)
pid_t pid = fork ();
if (pid == 0)
printf ("child => ppid: %d PID: %d \ n", getppid (), getPid ());
exit (exit_success);

sonst if (pid> 0)
printf ("parent => pid: %d \ n", getPid ());
printf ("Warten auf den Kinderprozess zu beenden.\N");
warte (null);
printf ("Kinderprozess abgeschlossen.\N");

anders
printf ("kann kein untergeordnetes Prozess erstellen.\N");

return exit_success;

Hier habe ich Fork () verwendet, um einen untergeordneten Prozess aus dem Haupt-/Elternprozess zu erstellen. Dann druckte ich die PID (Prozess -ID) und die PPID (übergeordnete Prozess -ID) aus dem Kinder- und übergeordneten Prozess aus. Beim übergeordneten Prozess wartt (NULL), um auf das Ende des Kinderprozesses zu warten. Beim Kinderprozess wird Exit () verwendet, um den Kinderprozess zu beenden. Wie Sie sehen können, ist die PID des übergeordneten Prozesses das PPID des Kinderprozesses. Also der Kinderprozess 24738 gehört zum Elternprozess 24731.

Sie können auch Funktionen verwenden, um Ihr Programm modularer zu gestalten. Hier habe ich benutzt processTask () Und Elterntask () Funktionen für die Kinder- und Elternprozesse. So wird Fork () tatsächlich verwendet.

#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
void Childtask ()
printf ("Hallo Welt \ n");

void parentTask ()
printf ("Hauptaufgabe.\N");

int main (void)
pid_t pid = fork ();
if (pid == 0)
ChildTask ();
exit (exit_success);

sonst if (pid> 0)
warte (null);
parentTask ();

anders
printf ("kann kein untergeordnetes Prozess erstellen.");

return exit_success;

Die Ausgabe des obigen Programms:

Ausführen mehrerer Kinderprozesse mit Fork () und Loop:

Sie können auch Schleife verwenden, um so viele Kinderprozesse zu erstellen, wie Sie benötigen. Im folgenden Beispiel habe ich 5 untergeordnete Prozesse für die Schleife erstellt. Ich habe auch die PID und die PPID aus den untergeordneten Prozessen gedruckt.

#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
int main (void)
für (int i = 1; i <= 5; i++)
pid_t pid = fork ();
if (pid == 0)
printf ("untergeordnetes prozess => ppid =%d, pid =%d \ n", getppid (), getPid ());
exit (0);

anders
printf ("Elternprozess => pid =%d \ n", getPid ());
printf ("Warten auf Kinderprozesse zu beenden ... \ n");
warte (null);
printf ("Kinderprozess abgeschlossen.\N");


return exit_success;

Wie Sie sehen können, ist die übergeordnete Prozess -ID in allen untergeordneten Prozessen gleich. Alle von ihnen gehören also demselben Elternteil. Sie führen auch linear aus. Einer nach dem anderen. Die Kontrolle von untergeordneten Prozessen ist eine ausgefeilte Aufgabe. Wenn Sie mehr über Linux -Systemprogrammierung und Funktionsweise erfahren, können Sie den Fluss dieser Prozesse trotzdem steuern, die Sie mögen.

Beispiel des wirklichen Lebens:

Verschiedene komplexe mathematische Berechnungen wie MD5, SHA256 usw. Die Hash -Generation erfordert viel Verarbeitungsleistung. Anstatt solche Dinge im selben Prozess wie das Hauptprogramm zu berechnen, können Sie den Hash nur für einen Kinderprozess berechnen und den Hash an den Hauptprozess zurückgeben.

Im folgenden Beispiel habe ich in einem untergeordneten Prozess einen 4-stelligen PIN-Code generiert und ihn an den übergeordneten Prozess, das Hauptprogramm, gesendet. Dann druckte ich den Pin -Code von dort aus.

#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
int getPin ()
// PPID und PID als Samen verwenden
srand (getPid () + getPlpid ());
int Secret = 1000 + Rand () % 9000;
Geheimnis zurückkehren;

int main (void)
int fd [2];
Pfeife (FD);
pid_t pid = fork ();
if (pid> 0)
schließen (0);
schließen (fd [1]);
DUP (FD [0]);
int SecretNumber;
size_t readBytes = read (fd [0], & SecretNumber, sizeof (SecretNumber));
printf ("Warten auf Pin ... \ n");
warte (null);
printf ("Bytes gelesen: %ld \ n", ReadBytes);
printf ("pin: %d \ n", SecretNumber);

sonst if (pid == 0)
schließen (1);
schließen (fd [0]);
DUP (FD [1]);
int Secret = getPin ();
write (fd [1], & geheim, sizeof (geheim));
exit (exit_success);

return exit_success;

Wie Sie sehen können, erhalte ich jedes Mal, wenn ich das Programm ausführe.

So verwenden Sie also den Fork () -Systemanruf unter Linux. Danke, dass du diesen Artikel gelesen hast.