Fork, exec, wait und exit system call erklärt in Linux | 11 Quick answer

Eine Reihe von Anweisungen und Daten, die mehrmals oder gleichzeitig ausgeführt werden können, wird als Programm bezeichnet. Und der Prozess besteht darin, solche Programme zu implementieren. Diese Prozesse können also viele Programme ausführen. Im selben Prozess kann das Betriebssystem mehrere Programme laden. Wiederverwendbare Prozesszustände wie aktuelles Verzeichnis, Berechtigungen, Dateimanager usw. von neuen Programmen geerbt. Solche Dinge passieren auf der gleichen Ebene wie Systemaufrufe wie fork(), exec(), wait() und exit().

In diesem Artikel werfen wir einen genaueren Blick auf die Linux-Systemaufrufe fork(), exec(), wait() und exit() mit Beispielen und Anwendungsfällen.

Villa (Riniert)

Das Fork()-System ist eines der einzigartigsten und nützlichsten für Linux/Unix-Systeme. Sie verwenden Prozesse, um Prozesse zu erstellen, die ihre eigenen Kopien sind. Mit solchen Systemaufrufen kann das Prozesskind die Hauptprozesse erstellen. Bis der Kinderprozess beendet ist, stoppt der Erziehungsprozess.

Hier sind einige wichtige Punkte in der Villa ().

• Der Elternprozess erhält eine Nicht-Null-ID für den Tochterprozess.
• Das Kind gibt Null zurück.
• Wenn beim Erstellen des untergeordneten Elements ein System- oder Hardwarefehler auftritt, wird -1 an die Verzweigung () zurückgegeben.
• Die eindeutige Prozess-ID des untergeordneten Prozesses stimmt nicht mit der ID einer vorhandenen Prozessgruppe überein.

Um mehr über die Funktion fork() zu erfahren, nehmen wir ein Beispiel, das das Konzept von fork() erklärt.

$ sudo vim fork.c

Hier ist der Copy/Paste-Code:

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>

int main(int argc, char **argv)

pid_t pid;
pid = fork();
if(pid==0)

printf("It is the child process and pid is %dn",getpid());
exit(0);

else if(pid > 0)

printf("It is the parent process and pid is %dn",getpid());

else

printf("Error while forkingn");
exit(EXIT_FAILURE);

return 0;

Abflüge:

$make fork

Wenn Sie das Skript ausführen, erhalten Sie das im folgenden Screenshot gezeigte Ergebnis.

$ ./fork

Tu es ()

Exec() ist ein Systemaufruf, der ausgeführt wird, indem das aktuelle Prozessabbild durch ein neues Prozessabbild ersetzt wird. Der ursprüngliche Prozess bleibt jedoch ein neuer Prozess, aber der neue Prozess ersetzt die Kopfdaten, die akkumulierten Daten und so weiter. Das Programm beginnt am Einstiegspunkt, indem es das Programm in den aktuellen Prozessraum lädt.

Nehmen Sie für eine weitere Erläuterung ein Beispiel wie folgt.

$ sudo vim exec.c

Und hier ist der Code:

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

main(void) 
  pid_t pid = 0;
  int status;
  pid = fork();

if (pid == 0) 
  printf("I am the child.");
  execl("/bin/ls", "ls", "-l", "/home/ubuntu/", (char *) 0);
  perror("In exec(): ");


if (pid > 0) 
  printf("I am the parent, and the child is %d.n", pid);
  pid = wait(&status);
  printf("End of process %d: ", pid);

  if (WIFEXITED(status)) 
    printf("The process ended with exit(%d).n", WEXITSTATUS(status));
  

  if (WIFSIGNALED(status)) 
    printf("The process ended with kill -%d.n", WTERMSIG(status));
  


if (pid < 0) 
  perror("In fork():");


exit(0);

Abflüge:

$ make exec

Wenn Sie das Skript ausführen, erhalten Sie das im folgenden Screenshot gezeigte Ergebnis.

$ ./exec

Warten ()

Wie bei einem Fork werden Tochterprozesse erstellt und ausgeführt, aber der Elternprozess hält an, bis der Tochterprozess abgeschlossen ist. In diesem Fall wird das Anklopfen des Systems () automatisch aktiviert, da der Hauptprozess stoppt. Wenn der untergeordnete Prozess die Implementierung abschließt, übernimmt der Hauptprozess wieder die Kontrolle.

Um mehr über das Warten zu erfahren, nehmen Sie ein Beispiel für einen wartenden Systemanruf (Warten).

$ sudo vim wait.c

Und hier ist ein Beispielcode:

#include<stdio.h> // printf()
#include<stdlib.h> // exit()
#include<sys/types.h> // pid_t
#include<sys/wait.h> // wait()
#include<unistd.h> // fork

int main(int argc, char **argv)


pid_t pid;
pid = fork();

if(pid==0)


printf("It is the child process and pid is %dn",getpid());

int i=0;
for(i=0;i<8;i++)

printf("%dn",i);


exit(0);


else if(pid > 0)


printf("It is the parent process and pid is %dn",getpid());

int status;
wait(&status);
printf("Child is reapedn");


else


printf("Error in forking..n");
exit(EXIT_FAILURE);



return 0;

Abflüge:

$ make wait

Wenn Sie das Skript ausführen, erhalten Sie das im folgenden Screenshot gezeigte Ergebnis.

$ ./wait

Ausgang ()

Die Funktion Output() ist eine Funktion oder ein Systemaufruf zum Beenden eines Prozesses. Dieser systematische Aufruf bestimmt die zu unterbrechende Thread-Ausführung, insbesondere in einer Multithread-Umgebung. Der Status des Prozesses wird dann als Referenz festgehalten.

Nachdem Sie den Systemaufruf-Exit verwendet haben, verlassen alle im Prozess verwendeten Ressourcen das Betriebssystem und beenden dann den Prozess. Das exit()-System entspricht einem ausgehenden ()-Anruf.

Zusammenfassung

#include <unistd.h>
void _exit(int status);
#include <stdlib.h>
void _Exit(int status);

Die Verwendung der Funktion output() kann aus den obigen Beispielen von fork() und wait() ersehen werden. Die Verwendung des Systemaufrufs output() markiert das Ende des Vorgangs.

Fazit

In diesem Artikel haben wir anhand einiger Beispiele Systemaufrufe unter Verwendung von fork(), exec(), wait() und exit() im Detail untersucht. Versuchen Sie für weitere Details, Programme mit diesen Systemaufrufen auszuführen, und sehen Sie sich das Ergebnis an. Vielen Dank!