Llamada del sistema de bifurcación en c

La llamada del sistema Fork () se utiliza para crear procesos infantiles en un programa C. Fork () se utiliza donde se requiere procesamiento paralelo en su aplicación. La función del sistema Fork () se define en los encabezados sys/tipos.H y unistd.H. En un programa donde usa Fork, también debe usar la llamada del sistema Wait (). Wait () La llamada del sistema se usa para esperar en el proceso principal para que el proceso infantil termine. Para finalizar un proceso infantil, la llamada del sistema Exit () se utiliza en el proceso infantil. La función Wait () se define en el encabezado sys/espera.H y la función EXIT () se define en el encabezado stdlib.H.

Fig. 1: flujo de trabajo básico de horquilla ()

En este artículo, le mostraré cómo usar la llamada del sistema Fork () para crear procesos infantiles en C. Entonces empecemos.

sintaxis de la bifurcación y valor de retorno:

La sintaxis de la función del sistema Fork () es la siguiente:

PID_T FORK (Void);

La función del sistema Fork () no acepta ningún argumento. Devuelve un entero del tipo pid_t.

Sobre el éxito, Fork () devuelve el PID del proceso infantil que es mayor que 0. Dentro del proceso del niño, el valor de retorno es 0. Si FORK () falla, entonces devuelve -1.

Ejemplo de horcajción simple ():

A continuación se da un ejemplo simple de horquilla ():

#incluir
#incluir
#incluir
#incluir
#incluir
int main (void)
pid_t pid = horqu ();
if (pid == 0)
printf ("child => ppid: %d pid: %d \ n", getppid (), getpid ());
salir (exit_success);

else if (pid> 0)
printf ("parent => pid: %d \ n", getpid ());
printf ("Esperando que el proceso infantil termine.\norte");
esperar (nulo);
printf ("Proceso infantil terminado.\norte");

demás
printf ("No se puede crear el proceso infantil.\norte");

return exit_success;

Aquí, utilicé Fork () para crear un proceso infantil desde el proceso principal/principal. Luego, imprimí el PID (ID de proceso) y el PPID (ID de proceso principal) del proceso infantil y principal. En el proceso principal, la espera (nulo) se utiliza para esperar a que el proceso infantil termine. En el proceso infantil, Exit () se usa para terminar el proceso infantil. Como puede ver, el PID del proceso principal es el PPID del proceso infantil. Entonces, el proceso del niño 24738 pertenece al proceso principal 24731.

También puede usar funciones para hacer que su programa sea más modular. Aquí, usé ProcessTask () y ParentTask () Funciones para los procesos de niños y padres respectivamente. Así es como se usa realmente fork ().

#incluir
#incluir
#incluir
#incluir
#incluir
void childTask ()
printf ("Hello World \ n");

void parentTask ()
printf ("Tarea principal.\norte");

int main (void)
pid_t pid = horqu ();
if (pid == 0)
ChildTask ();
salir (exit_success);

else if (pid> 0)
esperar (nulo);
parentTask ();

demás
printf ("No se puede crear el proceso infantil.");

return exit_success;

La salida del programa anterior:

Ejecutar múltiples procesos infantiles usando Fork () y Loop:

También puede usar el bucle para crear tantos procesos infantiles como sea necesario. En el ejemplo a continuación, he creado 5 procesos infantiles usando para bucle. También imprimí el PID y el PPID de los procesos infantiles.

#incluir
#incluir
#incluir
#incluir
#incluir
int main (void)
para (int i = 1; i <= 5; i++)
pid_t pid = horqu ();
if (pid == 0)
printf ("Proceso infantil => ppid =%d, pid =%d \ n", getppid (), getpid ());
salida (0);

demás
printf ("Proceso parent => pid =%d \ n", getpid ());
printf ("Esperando que los procesos infantiles terminen ... \ n");
esperar (nulo);
printf ("Proceso infantil terminado.\norte");


return exit_success;

Como puede ver, la identificación del proceso principal es la misma en todos los procesos infantiles. Entonces, todos pertenecen al mismo padre. También se ejecutan de manera lineal. Uno después del otro. Controlar los procesos infantiles es una tarea sofisticada. Si aprende más sobre la programación del sistema Linux y cómo funciona, podrá controlar el flujo de estos procesos de todos modos que desee.

Ejemplo de la vida real:

Diferentes cálculos matemáticos complejos como MD5, Sha256, etc., la generación de hash requiere mucha potencia de procesamiento. En lugar de calcular cosas como esa en el mismo proceso que el programa principal, puede calcular el hash en un proceso infantil y devolver el hash al proceso principal.

En el siguiente ejemplo, generé un código PIN de 4 dígitos en un proceso infantil y lo envié al proceso principal, el programa principal. Luego, imprimí el código PIN desde allí.

#incluir
#incluir
#incluir
#incluir
#incluir
int getPin ()
// usa PPID y PID como semilla
srand (getpid () + getppid ());
intecret = 1000 + rand () % 9000;
secreto de regreso;

int main (void)
int fd [2];
tubería (fd);
pid_t pid = horqu ();
if (pid> 0)
cerrar (0);
cerrar (fd [1]);
dup (fd [0]);
int SecretNumber;
size_t readbytes = read (fd [0], & SecretNumber, sizeOf (SecretNumber));
printf ("Esperando pin ... \ n");
esperar (nulo);
printf ("Bytes Read: %ld \ n", readbytes);
printf ("pin: %d \ n", secretnumber);

else if (pid == 0)
cerrar (1);
cerrar (fd [0]);
dup (fd [1]);
int Secret = getPin ();
escribir (fd [1] y secreto, sizeOf (secreto));
salir (exit_success);

return exit_success;

Como puede ver, cada vez que ejecuto el programa, obtengo un código PIN de 4 dígitos diferente.

Entonces, así es básicamente cómo usa la llamada del sistema Fork () en Linux. Gracias por leer este artículo.