Prozessbild überlagern
Angenommen, wir führen ein Programm aus und möchten ein anderes Programm aus dem aktuellen Programm ausführen. Ist das möglich? Warum nicht, wenn wir das Konzept der Überlagerung des Prozessabbilds implementieren. Das ist in Ordnung, aber was ist mit dem aktuell laufenden Programm? Kann das auch ausgeführt werden? Wie ist das möglich, da wir das aktuelle Programm mit dem neuen Programm überlagert haben. Was ist möglich, wenn ich die beiden Programme ausführen möchte, ohne das aktuell ausgeführte Programm zu verlieren? Ja, es ist möglich.
Erstellen Sie einen untergeordneten Prozess, sodass wir einen übergeordneten Prozess und einen neu erstellten untergeordneten Prozess haben. Wir führen das aktuelle Programm bereits im übergeordneten Prozess aus, führen Sie also den neu erstellten Prozess im untergeordneten Prozess aus. Auf diese Weise können wir ein anderes Programm aus dem aktuellen Programm ausführen. Nicht nur ein einzelnes Programm, sondern wir können eine beliebige Anzahl von Programmen aus dem aktuellen Programm ausführen, indem wir so viele untergeordnete Prozesse erstellen.
Betrachten wir das folgende Programm als Beispiel.
/ * Dateiname: helloworld.c * /
#include<stdio.h>
void main() {
printf("Hello World\n");
return;
}/ * Dateiname: execl_test.c * /
#include<stdio.h>
#include<unistd.h>
void main() {
execl("./helloworld", "./helloworld", (char *)0);
printf("This wouldn't print\n");
return;
}Das obige Programm würde das Prozessabbild von execl_test mit helloworld überlagern. Aus diesem Grund wird der Prozessabbildcode von execl_test (printf ()) nicht ausgeführt.
Kompilierungs- und Ausführungsschritte
Hello WorldJetzt werden wir die folgenden zwei Programme von einem Programm ausführen, dh execl_run_two_prgms.c.
Hallo Welt Programm (helloworld.c)
While-Schleifenprogramm zum Drucken von 1 bis 10 (while_loop.c)
/ * Dateiname: while_loop.c * /
/* Prints numbers from 1 to 10 using while loop */
#include<stdio.h>
void main() {
int value = 1;
while (value <= 10) {
printf("%d\t", value);
value++;
}
printf("\n");
return;
}Es folgt das Programm zum Ausführen von zwei Programmen (ein Programm vom Kind und ein anderes Programm vom Elternteil).
/ * Dateiname: execl_run_two_prgms.c * /
#include<stdio.h>
#include<unistd.h>
void main() {
int pid;
pid = fork();
/* Child process */
if (pid == 0) {
printf("Child process: Running Hello World Program\n");
execl("./helloworld", "./helloworld", (char *)0);
printf("This wouldn't print\n");
} else { /* Parent process */
sleep(3);
printf("Parent process: Running While loop Program\n");
execl("./while_loop", "./while_loop", (char *)0);
printf("Won't reach here\n");
}
return;
}Note - Setzen Sie den Aufruf sleep (), um sicherzustellen, dass die untergeordneten und übergeordneten Prozesse nacheinander ausgeführt werden (überlappen Sie das Ergebnis nicht).
Kompilierungs- und Ausführungsschritte
Child process: Running Hello World Program
This wouldn't print
Parent process: Running While loop Program
Won't reach hereJetzt würden wir zwei Programme von einem Programm ausführen, dh execl_run_two_prgms.c, dasselbe Programm wie oben, jedoch mit Befehlszeilenargumenten. Wir führen also zwei Programme aus, nämlich helloworld.c im untergeordneten Prozess und das Programm while_loop.c im übergeordneten Prozess. Dies ist wie folgt -
Hallo Welt Programm (helloworld.c)
While-Schleifenprogramm zum Drucken von 1 nach num_times_str gemäß den Befehlszeilenargumenten (while_loop.c)
Dieses Programm führt im Allgemeinen die folgenden Aktionen aus:
Erstellt einen untergeordneten Prozess
Der untergeordnete Prozess führt das Programm helloworld.c aus
Der übergeordnete Prozess führt das Programm while_loop.c aus und übergibt den Befehlszeilenargumentwert als Argument an das Programm. Wenn die Befehlszeilenargumente nicht übergeben werden, wird der Standardwert auf 10 gesetzt. Andernfalls wird der angegebene Argumentwert verwendet. Der Argumentwert sollte numerisch sein. Code würde nicht validiert, wenn er in Alphabeten angegeben wird.
/ * Dateiname: execl_run_two_prgms.c * /
#include<stdio.h>
#include<string.h>
#include<unistd.h>
void main(int argc, char *argv[0]) {
int pid;
int err;
int num_times;
char num_times_str[5];
/* In no command line arguments are passed, then loop maximum count taken as 10 */
if (argc == 1) {
printf("Taken loop maximum as 10\n");
num_times = 10;
sprintf(num_times_str, "%d", num_times);
} else {
strcpy(num_times_str, argv[1]);
printf("num_times_str is %s\n", num_times_str);
pid = fork();
}
/* Child process */
if (pid == 0) {
printf("Child process: Running Hello World Program\n");
err = execl("./helloworld", "./helloworld", (char *)0);
printf("Error %d\n", err);
perror("Execl error: ");
printf("This wouldn't print\n");
} else { /* Parent process */
sleep(3);
printf("Parent process: Running While loop Program\n");
execl("./while_loop", "./while_loop", (char *)num_times_str, (char *)0);
printf("Won't reach here\n");
}
return;
}Es folgt das Programm helloworld.c, das vom untergeordneten Prozess des Programms execl_run_two_prgms.c aufgerufen wird.
/ * Dateiname: helloworld.c * /
#include<stdio.h>
void main() {
printf("Hello World\n");
return;
}Es folgt das Programm while_loop.c, das vom übergeordneten Prozess des Programms execl_run_two_prgms.c aufgerufen wird. Das Argument an dieses Programm wird von dem Programm übergeben, das dies ausführt, dh execl_run_two_prgms.c.
/ * Dateiname: while_loop.c * /
#include<stdio.h>
void main(int argc, char *argv[]) {
int start_value = 1;
int end_value;
if (argc == 1)
end_value = 10;
else
end_value = atoi(argv[1]);
printf("Argv[1] is %s\n", argv[1]);
while (start_value <= end_value) {
printf("%d\t", start_value);
start_value++;
}
printf("\n");
return;
}Kompilierungs- und Ausführungsschritte
Taken loop maximum as 10
num_times_str is 10
Child process: Running Hello World Program
Hello World
Parent process: Running While loop Program
Argv[1] is 10
1 2 3 4 5 6 7 8 9 10
Taken loop maximum as 15
num_times_str is 15
Child process: Running Hello World Program
Hello World
Parent process: Running While loop Program
Argv[1] is 15
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15Lassen Sie uns nun die überlagerten bildbezogenen Bibliotheksfunktionen sehen.
#include<unistd.h>
int execl(const char *path, const char *arg, ...);Diese Funktion würde das aktuell laufende Prozessabbild mit dem neuen Prozess überlagern, wie in den Argumenten, Pfad und Argument angegeben. Wenn ein Argument an ein neues Prozessabbild übergeben werden muss, wird es über "arg" -Argumente gesendet, und das letzte Argument sollte NULL sein.
Diese Funktion würde nur im Fehlerfall einen Wert zurückgeben. Der Prozess, der bildbezogene Aufrufe überlagert, ist wie folgt:
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ..., char * const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]);Diese Aufrufe befassen sich mit übergebenen Befehlszeilenargumenten (argv []), Umgebungsvariablen (envp []) und anderen Parametern.