Perché sto biforcando più di 5 volte qui?

Question

Quindi ho il codice qui, e mi aspettavo che eseguisse rigorosamente ls -l 5 volte, ma sembra che funzioni molto più volte. Cosa sto facendo di sbagliato qui? Voglio eseguire ls 5 volte, quindi forzo 5 volte. Forse non capisco il concetto di aspettare correttamente? Sono andato oltre una tonnellata di tutorial, e nessuno sembra affrontare più processi utilizzando a fondo la forcella.

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

int main() 
{ 
    pid_t pidChilds[5]; 

    int i =0; 

    for(i = 0; i<5; i++) 
    { 
     pid_t cpid = fork(); 
     if(cpid<0) 
      printf("\n FORKED FAILED"); 
     if(cpid==0) 
      printf("FORK SUCCESSFUL"); 
     pidChilds[i]=cpid; 
    } 





} 

Answer 1

Quando si utilizza la forcella in C, è necessario immaginare il codice e lo stato del processo da copiare in un nuovo processo, a quel punto inizia l'esecuzione dal punto in cui era stato interrotto.

Quando si utilizza exec in C, è necessario immaginare che l'intero processo venga sostituito se la chiamata ha esito positivo.

Ecco il codice, riscritto per produrre il comportamento previsto. Si prega di leggere i commenti.

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

int main() 
{ 
    pid_t cpid; 
    pid_t pidChildren[5]; 

    int i; 
    for (i = 0; i < 5; i++) 
    { 
     cpid = fork(); 
     if (cpid < 0) { 
      printf("fork failed\n"); 
     } else if (cpid == 0) { 
      /* If we arrive here, we are now in a copy of the 
       state and code of the parent process. */ 
      printf("fork successful\n"); 
      break; 
     } else { 
      /* We are still in the parent process. */ 
      pidChildren[i] = cpid; 
     } 
    } 

    if (cpid == 0) { 
     /* We are in one of the children; 
      we don't know which one. */ 
     char *cmd[] = {"ls", "-l", NULL}; 
     /* If execvp is successful, this process will be 
      replaced by ls. */ 
     if (execvp(cmd[0], cmd) < 0) { 
      printf("execvp failed\n"); 
      return -1; 
     } 
    } 

    /* We expect that only the parent arrives here. */ 
    int exitStatus = 0; 
    for (i = 0; i < 5; i++) { 
     waitpid(pidChildren[i], &exitStatus, 0); 
     printf("Child %d exited with status %d\n", i, exitStatus); 
    } 

    return 0; 
} 

Answer 2

Si sta biforcandosi in un ciclo e la forcella quasi-copia il processo incluso il puntatore di istruzioni.

Significato: Ad esempio, il primo processo figlio si troverà in un ciclo che ha ancora 4 round da percorrere.

E ciascuno dei 4 processi che lo spawn di processo troverà deve andare 3 round in più.

E così via.

fork() restituisce se il processo in cui ci si trova è il processo padre o figlio. È necessario verificare il valore restituito e il ciclo break; se si è in un processo figlio.

"In caso di esito positivo, il PID del processo figlio viene restituito nel padre e 0 viene restituito nel figlio. In caso di errore, -1 viene restituito nel padre, nessun processo figlio viene creato e errno è impostato in modo appropriato. "

Quindi è necessario if(cpid==0) break;.

Answer 3

Ogni i 'th fork inizia all'interno del ciclo, in modo che verrà eseguito i restanti n-i iterazioni di quel ciclo, che si biforcano in modo ricorsivo.