Funzione Fork() in C

Question

Di seguito è riportato un esempio della funzione Fork in azione. Di seguito è riportato anche l'output. La mia domanda principale ha a che fare con un fork chiamato come i valori sono cambiati. Quindi pid1,2 e 3 partono da 0 e cambiano quando le forche si verificano. Questo perché ogni volta che si verifica un fork, i valori vengono copiati al figlio e il valore specifico viene modificato nel genitore? In pratica come cambiano i valori con le funzioni della forcella?

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

int main() { 
    pid_t pid1, pid2, pid3; 
    pid1=0, pid2=0, pid3=0; 
    pid1= fork(); /* A */ 
    if(pid1==0){ 
     pid2=fork(); /* B */ 
     pid3=fork(); /* C */ 
    } else { 
     pid3=fork(); /* D */ 
     if(pid3==0) { 
      pid2=fork(); /* E */ 
     } 
     if((pid1 == 0)&&(pid2 == 0)) 
      printf("Level 1\n"); 
     if(pid1 !=0) 
      printf("Level 2\n"); 
     if(pid2 !=0) 
      printf("Level 3\n"); 
     if(pid3 !=0) 
      printf("Level 4\n"); 
     return 0; 
    } 
} 

Quindi questa è l'esecuzione.

----A----D--------- (pid1!=0, pid2==0(as initialized), pid3!=0, print "Level 2" and "Level 4") 
    | | 
    | +----E---- (pid1!=0, pid2!=0, pid3==0, print "Level 2" and "Level 3") 
    |   | 
    |   +---- (pid1!=0, pid2==0, pid3==0, print "Level 2") 
    | 
    +----B----C---- (pid1==0, pid2!=0, pid3!=0, print nothing) 
     | | 
     | +---- (pid1==0, pid2==0, pid3==0, print nothing) 
     | 
     +----C---- (pid1==0, pid2==0, pid3!=0, print nothing) 
       | 
       +---- (pid1==0, pid2==0, pid3==0, print nothing) 

Idealmente sotto è come mi piacerebbe vederlo spiegato come in questo modo ha senso per me. I * sono dove risiede la mia principale confusione. Quando il bambino si biforca per esempio pid1 = fork(); che crea un processo con tutti i valori del genitore, ma poi passa un valore come diciamo 1 ai genitori pid1? Significa che il bambino avrebbe pid 1 = 0, pid2 = 0 e pid3 = 0 e il genitore allora come pid1 = 2 e pid2 e 3 uguale a 0?

Answer 1

int a = fork(); 

crea un processo duplicato "clone?", Che condivide lo stack di esecuzione. La differenza tra genitore e figlio è il valore di ritorno della funzione.

Il figlio riceve 0 restituito e il genitore riceve il nuovo pid.

Ogni volta che vengono copiati gli indirizzi e i valori delle variabili di stack. L'esecuzione continua nel punto in cui è già stata inserita nel codice.

A ogni fork, viene modificato solo un valore - il valore di ritorno da fork.

Answer 2

Prima un link ad una documentazione di fork()

http://pubs.opengroup.org/onlinepubs/009695399/functions/fork.html

il PID è fornito dal kernel. Ogni volta che il kernel creare un nuovo processo che farà aumentare il contatore PID interno e assegnare il nuovo processo di questo nuovo unico pid e anche assicurarsi che non vi siano duplicati. Una volta che il pid raggiunge un numero elevato, si avvolgerà e ricomincerà.

Quindi non si sa mai quale pid si otterrà da fork(), solo che il genitore manterrà il suo pid univoco e che il fork si assicurerà che il processo figlio abbia un nuovo pid univoco. Questo è indicato nella documentazione fornita sopra.

Se si continua a leggere la documentazione si vedrà che il ritorno fork() 0 per il processo figlio e il nuovo PID unica del bambino verrà restituito al genitore. Se il bambino vuole sapere che è il suo nuovo pid, dovrai interrogarlo usando getpid().

pid_t pid = fork() 
if(pid == 0) { 
    printf("this is a child: my new unique pid is %d\n", getpid()); 
} else { 
    printf("this is the parent: my pid is %d and I have a child with pid %d \n", getpid(), pid); 
} 

e sotto è alcuni commenti in linea sul vostro codice

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

int main() { 
    pid_t pid1, pid2, pid3; 
    pid1=0, pid2=0, pid3=0; 
    pid1= fork(); /* A */ 
    if(pid1 == 0){ 
     /* This is child A */ 
     pid2=fork(); /* B */ 
     pid3=fork(); /* C */ 
    } else { 
     /* This is parent A */ 
     /* Child B and C will never reach this code */ 
     pid3=fork(); /* D */ 
     if(pid3==0) { 
      /* This is child D fork'ed from parent A */ 
      pid2=fork(); /* E */ 
     } 
     if((pid1 == 0)&&(pid2 == 0)) { 
      /* pid1 will never be 0 here so this is dead code */ 
      printf("Level 1\n"); 
     } 
     if(pid1 !=0) { 
      /* This is always true for both parent and child E */ 
      printf("Level 2\n"); 
     } 
     if(pid2 !=0) { 
      /* This is parent E (same as parent A) */ 
      printf("Level 3\n"); 
     } 
     if(pid3 !=0) { 
      /* This is parent D (same as parent A) */ 
      printf("Level 4\n"); 
     } 
    } 
    return 0; 
} 

Answer 3

chiamata di sistema fork() viene utilizzato per creare i processi. Non accetta argomenti e restituisce un ID di processo. Lo scopo di fork() è creare un nuovo processo, che diventa il processo secondario del chiamante. Dopo aver creato un nuovo processo figlio, entrambi i processi eseguiranno l'istruzione successiva alla chiamata di sistema fork(). Pertanto, dobbiamo distinguere il genitore dal bambino.Questo può essere fatto testando il valore restituito di fork()

Fork è una chiamata di sistema e non dovreste pensare ad esso come una normale funzione C. Quando si verifica un fork() , si creano effettivamente due nuovi processi con il proprio spazio indirizzo. Variabili inizializzati prima che la chiamata a fork() memorizzi gli stessi valori nello spazio degli indirizzi. Tuttavia, i valori modificati nello spazio degli indirizzi di uno dei due processi rimangono inalterati nell'altro processo uno dei quali è padre e l'altro è secondario. Quindi, se,

pid=fork(); 

Se nei successivi blocchi di codice di controllare il valore di pid.Both processi vengono eseguiti per l'intera lunghezza del codice. Quindi, come li distinguiamo. Ancora Fork è una chiamata di sistema ed ecco la differenza. All'interno del processo figlio appena creato pid memorizzerà 0 mentre nel processo genitore verrà memorizzato un valore positivo. Un valore negativo all'interno di pid indica un errore di fork.

Quando testiamo il valore di pid per scoprire se è uguale a zero o maggiore di quello che stiamo effettivamente scoprendo se siamo nel processo figlio o il processo genitore.

Read more about Fork