Llamada del sistema de la bifurcación Linux

La llamada del sistema de la horquilla se utiliza para crear un nuevo procesos. El proceso recién creado es el proceso infantil. El proceso que llama a la bifurcación y crea un nuevo proceso es el proceso principal. Los procesos de niños y principales se ejecutan simultáneamente.

Pero los procesos de niños y principales residen en diferentes espacios de memoria. Estos espacios de memoria tienen el mismo contenido y cualquier operación realizada por un proceso no afectará el otro proceso.

Cuando se crea el niño procesos; Ahora ambos procesos tendrán el mismo contador de programa (PC), por lo que ambos procesos apuntarán a la misma instrucción siguiente. Los archivos abridos por el proceso principal serán los mismos para el proceso infantil.

El proceso infantil es exactamente el mismo que su padre, pero hay una diferencia en los ID de procesos:

1. La identificación del proceso del proceso infantil es una identificación de proceso única que es diferente de la identificación de todos los demás procesos existentes.
2. La identificación del proceso principal será la misma que la de la identificación del proceso de los padres del niño.

Propiedades del proceso infantil

Las siguientes son algunas de las propiedades que posee un proceso infantil:

1. Los contadores de la CPU y las utilizaciones de recursos se inicializan para restablecer a cero.
2. Cuando se termina el proceso principal, los procesos infantiles no reciben ninguna señal porque se restablece el atributo pr_set_pdeathsig en prctl ().
3. El hilo utilizado para llamar a la cotk () crea el proceso infantil. Entonces, la dirección del proceso infantil será la misma que la de los padres.
4. El descriptor del archivo del proceso principal es heredado por el proceso infantil. Por ejemplo, la compensación del archivo o estado de los indicadores y los atributos de E/S se compartirán entre los descriptores de archivo de los procesos de los niños y los principales. Entonces, el descriptor de archivo de la clase principal se referirá al mismo descriptor de archivo de la clase infantil.
5. Los descriptores de colas de mensajes abiertos del proceso principal son heredados por el proceso infantil. Por ejemplo, si un descriptor de archivo contiene un mensaje en el proceso principal, el mismo mensaje estará presente en el descriptor de archivo correspondiente del proceso infantil. Entonces podemos decir que los valores de la bandera de estos descriptores de archivos son los mismos.
6. De manera similar, los flujos de directorio abiertos serán heredados por los procesos infantiles.
7. El valor de holgura de temporizador predeterminado de la clase infantil es el mismo que el valor de holgura del temporizador actual de la clase principal.

Propiedades que no son heredadas por el proceso infantil

Las siguientes son algunas de las propiedades que no son heredadas por un proceso infantil:

1. Bloqueos de memoria
2. La señal pendiente de una clase infantil está vacía.
3. Proceso de bloqueos de registro asociados (fcntl ())
4. Operaciones de E/S asincrónicas y contenido de E/S.
5. Notificaciones de cambio de directorio.
6. Temporizadores como alarma (), setitimer () no son heredados por la clase infantil.

tenedor () en c

No hay argumentos en Fork () y el tipo de retorno de la bifurcación () es entero. Debe incluir los siguientes archivos de encabezado cuando se usa Fork ():

#incluir
#incluir
#incluir

Al trabajar con Fork (), se puede usar para el tipo pid_t Para los procesos de identificación como PID_T se define en .

El archivo de encabezado es donde se define Fork (), por lo que debe incluirlo en su programa para usar Fork ().

El tipo de retorno se define en y la llamada de la bifurcación () se define en . Por lo tanto, debe incluir ambos en su programa para usar la llamada del sistema Fork ().

Sintaxis de la bifurcación ()

La sintaxis de la llamada del sistema Fork () en Linux, Ubuntu es la siguiente:

PID_T FORK (Void);

En la sintaxis el tipo de retorno es pid_t. Cuando el proceso infantil se crea con éxito, el PID del proceso infantil se devuelve en el proceso principal y 0 se devolverá al proceso infantil en sí mismo.

Si hay algún error, entonces -1 se devuelve al proceso principal y el proceso infantil no se crea.

No se pasan argumentos a la bifurcación ().

Ejemplo 1: llamar a la fork ()

Considere el siguiente ejemplo en el que hemos utilizado la llamada del sistema Fork () para crear un nuevo proceso infantil:

#incluir
#incluir
#incluir
int main ()

tenedor();
printf ("Uso de la llamada del sistema Fork () \ n");
regresar 0;

PRODUCCIÓN:

Sysads@Linuxhint $ GCC Fork.Cordeo C -O
sysads@linuxhint $ ./tenedor
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()

En este programa, hemos usado Fork (), esto creará un nuevo proceso infantil. Cuando se crea el proceso infantil, tanto el proceso principal como el proceso del niño apuntarán a la siguiente instrucción (el mismo contador de programa). De esta manera, las instrucciones restantes o las declaraciones C se ejecutarán el número total de tiempos de proceso, eso es 2^norte Times, donde n es el número de llamadas del sistema Fork ().

Entonces, cuando la llamada de la bifurcación () se usa una vez como se indica anteriormente (2¹ = 2) Tendremos nuestra salida 2 veces.

Aquí cuando se usa la llamada del sistema Fork (), la estructura interna se verá como:

Considere el siguiente caso en el que se usa el horquilla () 4 veces:

#incluir
#incluir
#incluir
int main ()

tenedor();
tenedor();
tenedor();
tenedor();
printf ("Uso de la llamada del sistema Fork () \ n");
regresar 0;

Producción:

Sysads@Linuxhint $ GCC Fork.Cordeo C -O
sysads@linuxhint $ ./tenedor
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
Uso de la llamada del sistema Fork ()
sysads@linuxhint $

Ahora el número total de proceso creado es 2⁴ = 16 y tenemos nuestra declaración de impresión ejecutada 16 veces.

Ejemplo 2: Prueba si Fork () fue exitoso

En el siguiente ejemplo, hemos utilizado la construcción de la toma de decisiones para probar el valor (int) devuelto por Fork (). Y se muestran los mensajes correspondientes:

#incluir
#incluir
#incluir
int main ()

pid_t p;
p = bifurcado ();
if (p ==-1)

printf ("Hay un error al llamar a la fork () \ n");

if (p == 0)

printf ("Estamos en el proceso infantil \ n");

demás

printf ("Estamos en el proceso principal \ n");

regresar 0;

PRODUCCIÓN:

Sysads@Linuxhint $ GCC Fork.Cordeo C -O
sysads@linuxhint $ ./tenedor
Estamos en el proceso principal
Estamos en el proceso infantil

En el ejemplo anterior, hemos usado el tipo PID_T que almacenará el valor de retorno de la bifurcación (). La bifurcación () se llama en línea:

p = bifurcado ();

Por lo tanto, el valor entero devuelto por Fork () se almacena en P y luego P se compara con verificar si nuestra llamada Fork () fue exitosa.

Cuando se usa la llamada Fork () y el niño se crea con éxito, la identificación del proceso infantil se devolverá al proceso de los padres y 0 se devolverá al proceso del niño.La identificación del proceso infantil en el proceso de los padres no será la misma que la identificación del proceso infantil en el proceso infantil en sí mismo. En el proceso infantil, la identificación del proceso infantil será 0.

Con este tutorial, puede ver cómo comenzar con la llamada del sistema de la bifurcación en Linux.