Fig 1: Flusso di lavoro di base fork()
In questo articolo, ti mostrerò come utilizzare la chiamata di sistema fork() per creare processi figlio in C. Quindi iniziamo.
fork() Sintassi e valore di ritorno:
La sintassi della funzione di sistema fork() è la seguente:
pid_t fork(void);La funzione di sistema fork() non accetta alcun argomento. Restituisce un intero del tipo pid_t.
In caso di successo, fork() restituisce il PID del processo figlio che è maggiore di 0. All'interno del processo figlio, il valore restituito è 0. Se fork() fallisce, restituisce -1.
Semplice fork() Esempio:
Di seguito viene fornito un semplice esempio di fork():
#includere#includere
#includere
#includere
#includere
int main(void)
pid_t pid = fork();
if(pid == 0)
printf("Figlio => PPID: %d PID: %d\n", getppid(), getpid());
exit(EXIT_SUCCESS);
altrimenti if(pid > 0)
printf("Genitore => PID: %d\n", getpid());
printf("In attesa che il processo figlio finisca.\n");
attendere(NULL);
printf("Processo figlio terminato.\n");
altro
printf("Impossibile creare un processo figlio.\n");
restituire EXIT_SUCCESS;
Qui, ho usato fork() per creare un processo figlio dal processo principale/genitore. Quindi, ho stampato il PID (ID processo) e il PPID (ID processo genitore) dal processo figlio e padre. Sul processo padre wait(NULL) viene utilizzato per attendere il completamento del processo figlio. Sul processo figlio, exit() viene utilizzato per terminare il processo figlio. Come puoi vedere, il PID del processo padre è il PPID del processo figlio. Quindi, il processo bambino 24738 appartiene al processo genitore 24731.
Puoi anche usare le funzioni per rendere il tuo programma più modulare. Ecco, ho usato processTask() e genitoreCompito() funzioni rispettivamente per i processi figlio e genitore. Ecco come viene effettivamente utilizzato fork().
#includere#includere
#includere
#includere
#includere
void childTask()
printf("Ciao mondo\n");
void parentTask()
printf("Compito principale.\n");
int main(void)
pid_t pid = fork();
if(pid == 0)
childTask();
exit(EXIT_SUCCESS);
altrimenti if(pid > 0)
attendere(NULL);
parentTask();
altro
printf("Impossibile creare un processo figlio.");
restituire EXIT_SUCCESS;
L'output del programma precedente:
Esecuzione di più processi figlio utilizzando fork() e Loop:
Puoi anche usare il ciclo per creare tutti i processi figlio di cui hai bisogno. Nell'esempio seguente, ho creato 5 processi figlio utilizzando for loop. Ho anche stampato il PID e il PPID dai processi figlio.
#includere#includere
#includere
#includere
#includere
int main(void)
for(int i = 1; i <= 5; i++)
pid_t pid = fork();
if(pid == 0)
printf("Processo figlio => PPID=%d, PID=%d\n", getppid(), getpid());
uscita (0);
altro
printf("Processo padre => PID=%d\n", getpid());
printf("In attesa che i processi figlio finiscano... \n");
attendere(NULL);
printf("processo figlio terminato.\n");
restituire EXIT_SUCCESS;
Come puoi vedere, l'ID del processo padre è lo stesso in tutti i processi figlio. Quindi, appartengono tutti allo stesso genitore. Eseguono anche in modo lineare. Uno dopo l'altro. Il controllo dei processi figlio è un compito sofisticato. Se impari di più sulla programmazione del sistema Linux e su come funziona, sarai in grado di controllare il flusso di questi processi come preferisci.
Esempio di vita reale:
Diversi calcoli matematici complessi come md5, sha256 ecc. La generazione di hash richiede molta potenza di elaborazione. Invece di calcolare cose del genere nello stesso processo del programma principale, puoi semplicemente calcolare l'hash su un processo figlio e restituire l'hash al processo principale.
Nell'esempio seguente, ho generato un codice PIN a 4 cifre in un processo figlio e l'ho inviato al processo padre, il programma principale. Quindi, ho stampato il codice PIN da lì.
#includere#includere
#includere
#includere
#includere
int getPIN()
// usa PPID e PID come seme
srand(getpid() + getppid());
int segreto = 1000 + rand() % 9000;
segreto di ritorno;
int main(void)
int fd[2];
tubo(fd);
pid_t pid = fork();
if(pid > 0)
chiudi (0);
chiudi(fd[1]);
dup(fd[0]);
int numero segreto;
size_t readBytes = read(fd[0], &secretNumber, sizeof(secretNumber));
printf("In attesa del PIN... \n");
attendere(NULL);
printf("Byte letti: %ld\n", byte letti);
printf("PIN: %d\n", numerosegreto);
altrimenti if(pid == 0)
chiudere(1);
chiudi(fd[0]);
dup(fd[1]);
int segreto = getPIN();
write(fd[1], &secret, sizeof(secret));
exit(EXIT_SUCCESS);
restituire EXIT_SUCCESS;
Come puoi vedere, ogni volta che eseguo il programma, ottengo un codice PIN di 4 cifre diverso.
Quindi, questo è fondamentalmente il modo in cui usi la chiamata di sistema fork() in Linux. Grazie per aver letto questo articolo.