Cuando se ejecuta una llamada al sistema fork(), el procesador pasa al modo kernel.
Por lo tanto, al final de la llamada de bifurcación, se generó un nuevo proceso con una copia de casi todas las construcciones del proceso de llamada (como la pila, los datos de usuario y los programas de usuario, etc.)
También queda claro a partir de muchas explicaciones muy bien respondidas que cómo un proceso (un programador) puede identificar la diferencia entre un proceso secundario y un proceso principal. Según las muchas respuestas documentadas en SO y en otros lugares:
si una llamada a fork() devuelve 0, significa que es el proceso hijo el que llamó a fork() . Mientras que si el valor de retorno de
fork()es un entero positivo, significa que fork() se ejecutó en el proceso principal y el entero positivo devuelto es un PID del proceso secundario. Ignorando el caso de rendimientos de valor negativo en aras de la brevedad.
Espero que mi entendimiento anterior sea correcto :fingers_crossed:
Sin embargo, lo siguiente es lo que estoy tratando de entender mejor y, con suerte, con más detalles/profundidad:
(Disculpe mi ignorancia sobre el tema. Solo tengo curiosidad por entender esto mejor desde una perspectiva interna. Este tema y mi deseo de obtener una comprensión más clara al respecto literalmente ha comenzado a secuestrar mis sueños ahora: P)
¿Cómo sabe la llamada al sistema (que se invoca cuando se llama a fork() ) que ahora se está ejecutando como parte del proceso secundario y, por lo tanto , debería devolver 0?
En otras palabras, ¿cómo sabe la llamada del sistema que se está ejecutando en el contexto del proceso principal y, por lo tanto , ahora debería devolver el PID del proceso secundario esta vez y no 0?
¿O es tal que de los 2 procesos, dado que ambos son réplicas exactas, uno de ellos obtiene aleatoriamente el valor de retorno como 0 y el otro como el PID y luego , en función de cuál obtuvo qué valor de retorno, se considera padre y niño en consecuencia? :cara_pensante:
Estaría feliz de ser guiado en la dirección con cualquier recurso que deba pasar. Realmente agradecería cualquier ayuda en esta dirección en realidad. :orar:
Cuando se llama a fork() , un proceso genera un proceso secundario con segmentos de proceso duplicados o compartidos. Lo que eso significa es que en un programa, antes de llamar a fork() , solo hay un proceso o una unidad de ejecución. Después de que fork() regresa, hay dos procesos ejecutándose simultáneamente. Dado que ambos procesos tienen la misma pila de llamadas en este punto, parece que cada proceso acaba de llamar a fork() . En el proceso padre, el valor de retorno de fork() es el PID del proceso hijo. En el proceso hijo, el valor de retorno de fork() es 0.
Puedes ver esto con una demostración realmente simple:
#include <unistd.h> #include <stdio.h> int main(){ pid_t parent = getpid(); pid_t child = fork(); if(child != 0){ printf("I am the parent process. My PID is %d\n", parent); printf("Parent process terminating\n"); } else{ printf("I am the child process. My PID is %d\n", getpid()); printf(" My parent's PID is %d\n", parent); printf("Child process terminating\n"); } return 0; }Aquí hay una muestra ejecutada en mi computadora portátil:
$ gcc -o fork fork.c $ ./fork I am the parent process. My PID is 16048 Parent process terminating I am the child process. My PID is 16049 My parent's PID is 16048 Child process terminating $Tenga en cuenta que cuando ejecute esto, los PID serán diferentes. Además, la salida está sujeta a una condición de carrera, por lo que, a veces, el proceso principal volverá al shell antes de que el proceso secundario termine de imprimirse, por lo que podría verse así:
$ ./fork I am the parent process. My PID is 16265 Parent process terminating $ I am the child process. My PID is 16266 My parent's PID is 16265 Child process terminating Lo que es importante entender es que fork() hace que el único proceso de ejecución se divida en dos unidades independientes. Dado que cada proceso aún se genera desde el mismo programa (o código fuente), el comportamiento es el mismo para ambos procesos. La razón por la que su salida difiere solo se debe al hecho de que fork() devuelve valores diferentes para los procesos principales o secundarios.