tenedor() en C

Se usa una llamada al sistema de bifurcación para crear un nuevo proceso, llamado proceso hijo, que se ejecuta simultáneamente con el proceso que realiza la llamada fork() (proceso principal). Después de crear un nuevo proceso hijo, ambos procesos ejecutarán la siguiente instrucción después de la llamada al sistema fork(). Un proceso hijo usa la misma computadora (contador de programa), los mismos programas de CPU, los mismos archivos abiertos usados ​​por el proceso padre.

No toma parámetros y devuelve un valor entero. A continuación se muestran los diferentes valores devueltos por fork().

Valor negativo: la creación del proceso secundario falló.
cero: Vuelva al proceso secundario recién creado.
Valor positivo: Devolver al padre oa la persona que llama. El valor contiene el ID de proceso del proceso secundario recién creado.

Nota: fork() es una función basada en subprocesos, para obtener el resultado correcto, ejecute el programa en un sistema local.

Tenga en cuenta que los programas anteriores no se combinan en un entorno de Windows.

1. Obtenga una vista previa de la salida del siguiente programa:.

   
   
   

   #include <stdio.h> #include <sys/types.h> #include <unistd.h> int main() {       // make two process which run same     // program after this instruction     fork();       printf("Hello world!n");     return 0; }

   Producción:

   Hello world!
   Hello world!
   

2. Calcular el número de veces que se imprime hello:

   
   
   

   #include <stdio.h> #include <sys/types.h> int main() {     fork();     fork();     fork();     printf("hellon");     return 0; }

   Producción:

   hello
   hello
   hello
   hello
   hello
   hello
   hello
   hello
   

   El número de veces que se imprime ‘hola’ es igual al número de procesos creados. Número total de procesos = 2^norte, donde n es el número de llamadas al sistema de bifurcación. Así que aquí n = 3, 2³ =8

   Pongamos algunos nombres de etiquetas en las tres líneas:

   fork ();   // Line 1
   fork ();   // Line 2
   fork ();   // Line 3
   
          L1       // There will be 1 child process 
       /          // created by line 1.
     L2      L2    // There will be 2 child processes
    /      /     //  created by line 2
   L3  L3  L3  L3  // There will be 4 child processes 
                   // created by line 3
   
   

   Entonces, hay ocho procesos en total (nuevos procesos secundarios y un proceso original).

   Si queremos representar la relación entre los procesos como un árbol jerárquico quedaría de la siguiente manera:

   Proceso principal: P0
   Procesos creados por la 1ra bifurcación: P1
   Procesos creados por la segunda bifurcación: P2, P3
   Procesos creados por la tercera bifurcación: P4, P5, P6, P7

                P0
            /   |   
          P1    P4   P2
         /            
       P3    P6         P5
      /
    P7
   

3. Obtenga una vista previa de la salida del siguiente programa:

   
   
   

   #include <stdio.h> #include <sys/types.h> #include <unistd.h> void forkexample() {     // child process because return value zero     if (fork() == 0)         printf("Hello from Child!n");       // parent process because return value non-zero.     else         printf("Hello from Parent!n"); } int main() {     forkexample();     return 0; }

   Producción:

   1.
   Hello from Child!
   Hello from Parent!
        (or)
   2.
   Hello from Parent!
   Hello from Child!
   

   En el código anterior, se crea un proceso secundario. fork() devuelve 0 en el proceso hijo y un entero positivo en el proceso padre.
   Aquí, dos salidas son posibles porque el proceso principal y el proceso secundario se ejecutan simultáneamente. Por lo tanto, no sabemos si el sistema operativo le dará el control al proceso principal o al proceso secundario primero.

   Importante: Un proceso principal y un proceso secundario ejecutan el mismo programa, pero eso no significa que sean idénticos. El sistema operativo asigna diferentes datos y estados para estos dos procesos, y el flujo de control de estos procesos puede ser diferente. Vea el siguiente ejemplo:

4. Obtenga una vista previa de la salida del siguiente programa:

   
   
   

   #include <stdio.h> #include <sys/types.h> #include <unistd.h>   void forkexample() {     int x = 1;       if (fork() == 0)         printf("Child has x = %dn", ++x);     else         printf("Parent has x = %dn", --x); } int main() {     forkexample();     return 0; }

   Producción:

   Parent has x = 0
   Child has x = 2
        (or)
   Child has x = 2
   Parent has x = 0
   

   Aquí, cambiar una variable global en un proceso no afecta a otros dos procesos porque los datos/estado de los dos procesos son diferentes. Y padre e hijo también se ejecutan al mismo tiempo para que se puedan realizar dos salidas.

bifurcación () frente a exec ()

La llamada al sistema de bifurcación crea un nuevo proceso. El nuevo proceso creado por fork() es una copia del proceso actual excepto por el valor devuelto. La llamada al sistema exec() reemplaza el proceso actual con un nuevo programa.

Práctica:

1. El proceso ejecuta el siguiente código:

   
   
   

   for (i = 0; i < n; i++)     fork();

   El número total de procesos secundarios creados es: (GATE-CS-2008)
   (Un
   (B) 2 ^n – 1
   (C) 2 ^n
   (D) 2^(n+1) – 1;

   Vea esto para una solución.

2. Considere el siguiente fragmento de código:

   
   
   

   if (fork() == 0) {     a = a + 5;     printf("%d, %dn", a, &a); } else {     a = a –5;     printf("%d, %dn", a, &a); }

   Sean u, v los valores impresos por el proceso padre, y x, y los valores impresos por el proceso hijo. ¿Cuál de las siguientes es VERDADERA? (GATE-CS-2005)
   (A) u = x + 10 y v = y
   (B) u = x + 10 y v!=y
   (C) u + 10 = x y v = y
   (D) u + 10 = x y v!=y
   Vea esto para una solución.

3. Obtenga una vista previa de la salida del programa a continuación.

   
   
   

   #include <stdio.h> #include <unistd.h> int main() {     fork();     fork() && fork() || fork();     fork();       printf("forkedn");     return 0; }

   Ver esto para una solución

Artículos relacionados :
Programa en C para demostrar fork() y pipe()
Procesos zombies y huérfanos en C
fork() procesos y memoria compartida b/w creados usando.

Referencias:
http://www.csl.mtu.edu/cs4411.ck/www/NOTES/process/fork/create.html

Este artículo ha sido agregado El equipo GeeksforGeeks y como patel. Si te gusta GeeksforGeeks y quieres contribuir, también puedes escribir un artículo usándolo. escribir.geeksforgeeks.org o envíe su artículo por correo a review-team@geeksforgeeks.org. Vea su artículo destacado en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba un comentario si encuentra algún problema o si desea compartir más información sobre el tema tratado anteriormente.