Proceso zombie vs proceso huérfano

8 minutos de lectura

Proceso zombie vs proceso huerfano
MarkAWard

Un zombi se crea cuando un proceso principal no utiliza la llamada al sistema de espera después de que un hijo muere para leer su estado de salida, y un huérfano es un proceso secundario que init reclama cuando el proceso principal original finaliza antes que el secundario.

En términos de administración de memoria y la tabla de procesos, ¿cómo se manejan estos procesos de manera diferente, específicamente en UNIX?

¿Cuál es un ejemplo o caso extremo en el que la creación de zombis o huérfanos puede ser perjudicial para la aplicación o el sistema mayor?

  • crea muchos zombis y mira tu sistema ssssllooooowwww

    – dbarnes

    19 de diciembre de 2013 a las 18:26

  • No hay razón para que un proceso zombie consuma (una cantidad no trivial de) memoria… está muerto. Básicamente es un marcador de posición para que el padre aún pueda leer el estado de salida en algún momento en el futuro.

    – Error fatal

    19 de diciembre de 2013 a las 18:28

  • El zombi no ocupa ninguna memoria o recursos significativos, es (efectivamente) solo un estado de salida que espera ser entregado. Un huérfano es un proceso vivo y en ejecución como cualquier otro, solo que tiene un nombre peculiar.

    -Clinton Pierce

    19 dic 2013 a las 18:30

  • @clintp pero un huérfano no puede convertirse en un proceso zombie ya que el sistema operativo lo manejará una vez que se complete.

    – MarkAWard

    19 de diciembre de 2013 a las 18:37

  • Si hay un error en el init proceso, o un error del kernel que impide init de funcionar correctamente, un proceso huérfano podría convertirse en un zombi. De otra manera no. Pero viéndolo de otra manera, cada proceso que sale es un zombi hasta que el padre lo limpia, así que sí, se convierten en zombis, pero no por mucho tiempo.

    usuario2404501

    19 de diciembre de 2013 a las 18:52

Cuando un niño sale, algún proceso debe wait en él para obtener su código de salida. Ese código de salida se almacena en la tabla de procesos hasta que esto suceda. El acto de leer ese código de salida se llama “cosechar” al niño. Entre el momento en que un niño sale y es cosechado, se le llama zombi. (Toda la nomenclatura es un poco espantosa cuando lo piensas; recomiendo no pensar demasiado en eso).

Los zombis solo ocupan espacio en la tabla de procesos. No toman memoria ni CPU. Sin embargo, la tabla de procesos es un recurso finito y un exceso de zombis puede llenarla, lo que significa que no se pueden iniciar otros procesos. Más allá de eso, son un desorden molesto y deben evitarse encarecidamente.

Si un proceso sale con hijos aún en ejecución (y no mata a sus hijos; la metáfora sigue siendo extraña), esos hijos son huérfanos. Los niños huérfanos son inmediatamente “adoptados” por init (En realidad, creo que la mayoría de la gente llama a esto “reparentalidad”, pero “adopción” parece llevar mejor la metáfora). Un huérfano es sólo un proceso. Utilizará los recursos que utilice. Es razonable decir que no es un “huérfano” en absoluto ya que tiene un padre, pero los he oído llamar así a menudo.

init recoge automáticamente a sus hijos (adoptados o no). Entonces, si sale sin limpiar a sus hijos, entonces no se convertirán en zombis (al menos no por más de un momento).

Pero los zombis longevos existen. ¿Qué son? Son los antiguos hijos de un proceso existente que no los ha cosechado. El proceso puede estar colgado. O puede estar mal escrito y olvidar cosechar a sus hijos. O tal vez está sobrecargado y no lo ha solucionado. O lo que sea. Pero por alguna razón, el proceso principal continúa existiendo (por lo que no son huérfanos), y no se les ha atendido, por lo que viven como zombis en la tabla de procesos.

Entonces, si ve zombis por más de un momento, significa que hay algún problema con el proceso principal y se debe hacer algo para mejorar ese programa.

Cuando finaliza un proceso, el sistema operativo desasigna sus recursos. Sin embargo, su entrada en la tabla de procesos debe permanecer ahí hasta que el padre llame a wait(), porque la tabla de procesos contiene el estado de salida del proceso. Un proceso que ha terminado, pero cuyo padre aún no ha llamado a wait(), se conoce como proceso zombi. Todos los procesos pasan a este estado cuando terminan, pero generalmente existen como zombis solo brevemente. Una vez que el padre llama a wait(), se liberan el identificador de proceso del proceso zombi y su entrada en la tabla de procesos.

Ahora considere lo que sucedería si un padre no invocara wait() y en su lugar terminara, dejando así sus procesos secundarios como huérfanos. Linux y UNIX abordan este escenario asignando el proceso init como el nuevo padre de los procesos huérfanos. El proceso init invoca periódicamente wait(), lo que permite recopilar el estado de salida de cualquier proceso huérfano y liberar el identificador del proceso huérfano y la entrada de la tabla de procesos.

Fuente: Conceptos del sistema operativo por Abraham, Pedro, Greg

  • Realmente me gustó esta respuesta breve y nítida.

    – Azim

    11/11/2016 a las 18:57

  • Entonces, de hecho, no hay huérfanos, ya que son adoptados.

    – alk

    7 de enero de 2017 a las 12:56

Un proceso huérfano es un proceso computacional cuyo parent process ha terminado o terminado, aunque (el proceso secundario) sigue ejecutándose.
A proceso zombi o un proceso difunto es un proceso que completó la ejecución pero aún tiene una entrada en la tabla de procesos ya que su proceso principal no invocó un wait() llamada del sistema.

Proceso zombie vs proceso huerfano
Omkar

Huérfano: salida principal, el proceso de inicio se convierte en el principal del proceso secundario. Cada vez que se finaliza el elemento secundario, os elimina la tabla de procesos.

Zombi: cuando el hijo termina, le da el estado de salida al padre. Mientras tanto, suponga que su padre está dormido y no puede recibir ningún estado del niño. Aunque el niño sale pero el proceso ocupa espacio en la tabla de procesos

echa un vistazo a este comando en linux ubuntu >>ps -eo pid,ppid,status,cmd

Si encontró algo como defunc al final, es decir, su proceso es zombie y ocupa espacio.

Proceso de zombis:
Un proceso que ha terminado la ejecución pero aún tiene una entrada en la tabla de procesos para informar a su proceso principal se conoce como proceso zombi. Un proceso hijo siempre se convierte primero en un zombi antes de ser eliminado de la tabla de procesos. El proceso principal lee el estado de salida del proceso secundario que extrae la entrada del proceso secundario de la tabla de procesos.

Proceso huérfano:
Un proceso cuyo proceso principal ya no existe, es decir, finalizó o finalizó sin esperar a que finalice su proceso secundario, se denomina proceso huérfano.

  1. No hay huérfanos sino el proceso usando PID 1.

    Desde el punto de vista del proceso en ejecución, no importa si se inició directamente y, por lo tanto, tiene el PID 1 como padre o si lo heredó el PID 1 porque su padre original (que es diferente del PID 1) finalizó. Se maneja como cualquier otro proceso.

  2. Cada proceso pasa por una especie de estado zombi, cuando finaliza, es decir, la fase entre anunciar su final emitiendo SIGCHLD y tener su tratamiento (entrega o desconocimiento) reconocido.

Cuando se ha ingresado al estado zombie, el proceso es solo una entrada en la lista de procesos del sistema.

El único recurso significativo que utiliza exclusivamente un zombi es un PID válido.

1646751373 382 Proceso zombie vs proceso huerfano
Comunidad

Me gustaría agregar 2 fragmentos de código con un proceso huérfano y otro zombi. Pero primero, publicaré la definición de estos procesos como se indica en el libro “Conceptos de sistemas operativos” de Silberschatz, Galvin y Gagn:

Si ningún padre espera (no invocó esperar()) el proceso es un zombi

Si el padre finalizó sin invocar la espera, el proceso es un huérfano

Huérfano

// A C program to demonstrate Orphan Process.  
// Parent process finishes execution while the 
// child process is running. The child process 
// becomes orphan. 

#include <stdio.h>  //printf
#include <stdlib.h> //exit
#include <sys/types.h> //fork
#include <unistd.h> //fork and sleep
  
int main() 
{ 
    // Fork returns process id 
    // in parent process 
    pid_t child_pid = fork(); 
  
    // Parent process didn't use wait and finished before child
    // so the child becomes an orphan process

    // Parent process 
    if (child_pid > 0) {
        printf("I finished my execution before my child"); 
    }
    else // Child process 
        if (child_pid == 0) { 
            sleep(1); //sleep for 1 second
            printf("This printf will not be executed"); 
        } 
        else{
            //error occurred
        }
  
    return 0; 
}

Producción

Terminé mi ejecución antes que mi hijo

Zombi

// A C program to demonstrate Zombie Process. 
// Child becomes Zombie as parent is not waiting
// when child process exits. 

#include <stdio.h>  //printf
#include <stdlib.h> //exit
#include <sys/types.h> //fork
#include <unistd.h> //fork and sleep

int main() 
{ 
    // Fork returns process id 
    // in parent process 
    pid_t child_pid = fork(); 
 
    // Parent process didn't use wait 
    // so the child becomes a zombie process

    // Parent process 
    if (child_pid > 0){ 
        sleep(1); //sleep for 1 second
        printf("\nI don't wait for my child");
    }
    else // Child process 
        if(child_pid == 0){ 
            printf("My parent doesn't wait me");
            exit(0);
        }
        else{
            //error occurred
        }
    
    return 0; 
} 

Producción

mi padre no me espera

no espero a mi hijo

Editar: Fuente e inspiración tomadas de aquí

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad