No entiendo este ejemplo de fork()

Question

Tengo este ejemplo de código, pero no entiendo por qué este código crea 5 procesos más el original. (6 proceso total)

#include <unistd.h> 

int main(void) { 
    int i; 
    for (i = 0; i < 3; i++) { 
     if (fork() && (i == 1)) { 
      break; 
     } 
    } 
} 

Answer 1

fork() divide un proceso en dos y devuelve 0 (si este proceso es el secundario) o el PID del hijo (si este proceso es el primario). Por lo tanto, esta línea:

if (fork() && (i == 1)) break; 

dice: "Si este es el proceso padre, y esta es la segunda vez a través del bucle, romper el bucle". Esto significa que el bucle se ejecuta como esto:

• i == 0: La primera vez a través del bucle, i es 0, creamos dos procesos, tanto de entrar en el bucle en i == 1. total ahora dos procesos

• i == 1: Ambos de los procesos tenedor, pero dos de ellos no siguen una iteración debido a la línea if (fork() && (i == 1)) break; (los dos que no continúan son ambos de los padres en las llamadas de horquilla) Total ahora cuatro procesos, pero solo dos de ellos siguen en bucle.

• i == 2: Ahora, los dos que continúan el bucle en la horquilla, dando como resultado 6 procesos.

• i == 3: Todos los 6 procesos de salir del bucle (desde i < 3 == false, no hay más looping)

Answer 2

En los niños procesa el ciclo continúa para iterar. Entonces ellos producen nuevos procesos también.

Answer 3

el ciclo se ejecuta desde i==0 hasta i==2.

En la primera iteración, el proceso original (p0) crear otro (p1)

En la segunda iteración, p0 y p1 crear uno nuevo proceso de cada uno (P2 y P3), y la rotura (Desde i==1 y fork devuelve un valor distinto de cero al padre).

En la tercera iteración, p2 y p3 crean un nuevo proceso cada uno (p4 y p5).

Así que, por fin, tienes 5 nuevos procesos.

Answer 4

puedo contar seis procesos (X) aquí:

i=0   fork() 
      / \ 
i=1 fork()  fork() 
    / \>0  / \>0 
     | X break | X break 
i=2 fork()  fork() 
    /\  /\ 
    X X   X X 

Answer 5

Primero tener un proceso Tenga en cuenta las iteraciones del ciclo:

i = 0 

El primer proceso llama fork. Ahora tenemos 2 procesos.

i = 1 

Los dos procesos llaman fork. Ahora tenemos 4.

Fork devuelve 0 en los procesos recién creados: Dos procesos se romperán del ciclo y dos continuarán en el ciclo.

i = 2 

Los dos procesos restantes llaman fork. Obtenemos 2 procesos nuevos (un total de 6).

Answer 6

En el proceso principal, fork() devuelve el PID del proceso secundario, y en el proceso secundario, devuelve 0. Teniendo esto en cuenta, observe cada iteración del ciclo for: (Digamos por simplicidad en aras de que el PID del proceso original es 1)

1. i == 0
   • proceso 1: i == 0, tenedor retornos PID del proceso hijo (por ejemplo 2) (2 = 0), verdadero & & falso == falso, por lo que no se rompe.
   • Proceso 2: i = 0, fork devuelve 0, falso & & falso == falso, por lo que no se rompe.
2. i == 1
   • Proceso 1: i == 1, tenedor devuelve PID de proceso hijo (digamos 3), la verdadera & & cierto == true, por lo que romper.
   • Proceso 2: i == 1, fork devuelve el PID del proceso hijo (por ejemplo 4), verdadero & & true == true, por lo que break.
   • Proceso 3: i == 1, fork devuelve 0, falso & & true == falso, por lo tanto, no se rompa.
   • Proceso 4: i == 1, fork devuelve 0, falso & & true == falso, por lo tanto, no se rompa.
3. i == 2
   • Proceso 1 está fuera del bucle.
   • El proceso 2 está fuera de circuito.
   • Proceso 3: i == 2, tenedor devuelve PID de proceso hijo (digamos 5), la verdadera & & falsa == false, por lo que no se rompen
   • Proceso 4: i == 2, tenedor devuelve PID de proceso hijo (por ejemplo 6), la verdadera & & falsa == false, por lo que no se rompen
   • proceso 5: i == 2, declaraciones de horquilla 0, falsos & & falsa == false, por lo que no se rompen
   • Proceso 6: i == 2, fork devuelve 0, falso & & falso == falso, por lo que no se rompe
4. i == 3 así que termine con el ciclo.

Answer 7

Si su proceso principal tiene una PID A y B - F son subprocesos PID, entonces:

A spawns B   i=0 
A spawns C   i=1 
C run from 'fork' i=1 
C spawns D   i=2 
B run from 'fork' i=0 
B spawns E   i=1 
D run from 'fork' i=2 
E run from 'fork' i=1 
E spawns F   i=2 
F run from 'fork' i=2 

Dónde i es el valor de i de la (sub) proceso de contexto. Desde fork crea una copia exacta del proceso en ejecución, la variable i también se copiarán. Cuando A genera B, i es 0. Cuando A genera C, i es 1. El proceso A ahora sale del for-loop ya que i == 1.

Ahora, el subproceso C comienza a ejecutarse, con i == 1. Tenga en cuenta que no se romperá dentro del for-loop ya que fork(), en C punto de desove, devuelve 0. En su lugar, se repetirá, aumentando i a 2, engendrando D, y saldrá debido a la condición for-loop.

El subproceso B tienen i == 0, cuando se inicia. Genera el subproceso E y se rompe dentro del for-loop. (I == 1)

Y así sucesivamente ...

Cuando está tyring para averiguar de cosas como estas, te puedo dar un consejo:

Hacer variables intermedias e imprimirlas.

he modificado su código, para que se imprima un vistazo a las cosas que acabo de describir:

#include <unistd.h> 
#include <stdio.h> 

int main(void) { 
    int i; 
    for (i= 0; i < 3; ++i) { 
     int f = fork(); 
     printf("%i\tspawns\t%i\ti=%i\n", getpid(), f, i); 
     if (f && (i == 1)) 
      break; 
    } 

    getchar(); 
}