¿Por qué la aplicación permanece en el proceso del administrador de tareas incluso después de cerrarla?
¡El llamado proceso zombie!
En el proceso fork()/execve(), se supone que el proceso padre todavía existe cuando finaliza el proceso hijo, y el proceso padre aún existe cuando finaliza el proceso hijo. El proceso no se ha instalado antes de fork() La función de procesamiento de señales SIGCHLD llama a waitpid() para esperar a que finalice el proceso hijo y no ignora explícitamente la señal. El proceso hijo se convierte en un proceso zombie y no puede finalizar normalmente. , Incluso la identidad raíz kill -9 no puede matar el proceso zombie. La solución es eliminar el proceso principal del proceso zombie (el proceso principal del proceso zombie debe existir). El proceso zombie se convierte en un "proceso huérfano" y es adoptado por el proceso número 1, init siempre será responsable. limpiando el proceso zombie.
Un proceso zombie significa que el proceso padre ha salido, y si ningún proceso acepta el proceso después de que está muerto, se convierte en un proceso zombie (zombie).
Cómo generar. un proceso zombie:
p>
Cuando un proceso llama al comando de salida para terminar su vida, en realidad no se destruye, sino que deja una estructura de datos llamada proceso zombie (Zombie) (el sistema llama salir, su función hace que el proceso salga, pero solo se limita a convertir un proceso normal en un proceso zombie y no puede destruirlo por completo). Entre los estados de los procesos de Linux, un proceso zombie
es un tipo muy especial. Ha cedido casi todo el espacio de memoria, no tiene ningún código ejecutable y no se puede programar. Solo retiene uno en el. lista de procesos. La ubicación registra el estado de salida del proceso y otra información para que otros procesos la recopilen. Además, el proceso zombie ya no ocupa espacio en la memoria. Necesita que su proceso principal recopile su cadáver. Si su proceso principal no instala la función de procesamiento de señales SIGCHLD, llama a esperar o esperar a que finalice el proceso secundario y no ignora explícitamente la señal. en el estado zombie, si el proceso principal finaliza en este momento, el proceso de inicio se hará cargo automáticamente del proceso secundario y recolectará sus cadáveres. Pero si el proceso principal es un bucle y no finaliza, entonces el proceso secundario permanecerá en un estado zombie. Es por eso que a veces hay muchos procesos zombies en el sistema.
Cómo verificar procesos zombies:
Usando el comando ps, puedes ver que el proceso marcado Z es un proceso zombie.
Cómo borrar procesos zombies:
1. Reescribe el proceso principal y recoge su cadáver después de la muerte del proceso secundario. El método específico consiste en hacerse cargo de la señal SIGCHLD. Después de que el proceso hijo muere, la señal SIGCHLD se envía al proceso padre. Después de que el proceso padre recibe esta señal, ejecuta la función waitpid () para recopilar el cadáver del proceso hijo. Esto se basa en el principio de que incluso si el proceso principal no llama a esperar, el kernel le enviará un mensaje SIGCHLD. Aunque el procesamiento predeterminado es ignorarlo, si desea responder a este mensaje, puede configurar una función de procesamiento. .
2. Mata el proceso padre. Una vez que el proceso principal muere, el proceso zombie se convierte en un "proceso huérfano" y se adopta para el proceso número 1. Init siempre será responsable de limpiar el proceso zombie. Todos los procesos zombies que generó también desaparecieron.
============================================ =
En Linux puedes usar
ps auwx
Descubrir procesos zombies
todos con tty, incluidos otros usuarios de todas las ventanas y Terminal, incluidos los procesos de otros usuarios
u orientado al usuario (fácil de usar)
-w, w salida ancha salida de gran formato
x procesos w /o controlando ttys
Se marcará después del proceso zombie
ps axf
Mire el árbol de procesos y muestre la lista de procesos en formato de árbol
ps axm
enumerará los subprocesos. En Linux, los procesos y los subprocesos están unificados y son dos formas de procesos livianos.
ps axu
Mostrar estado detallado del proceso
====================== = =====================
matar a todos
matar -15
matar -9
Generalmente, los procesos inactivos no se pueden eliminar
Después de usar kill -15, kill -9 y posteriores, aparecerán más procesos zombies
kill -kill pid
fuser -k pid
Puedes considerar matar su proceso padre,
matar -9 su proceso padre
= ==== ======================================
Un proceso que tiene ha sido terminado pero cuyo proceso padre aún no ha procesado las consecuencias (obtener información sobre el proceso hijo terminado y liberar los recursos que aún ocupa) se denomina proceso zombie.
Métodos para evitar zombies:
1) En SVR4, si se llama a signal o sigset para establecer la configuración de SIGCHLD en ignorar, no se generarán procesos secundarios zombie. Además, al utilizar la versión SVR4 de sigaction, puede configurar el indicador SA_NOCLDWAIT para evitar procesos secundarios zombies.
Esto también se puede usar en Linux, llamando a esta función al comienzo de un programa
signal(SIGCHLD, SIG_IGN
2) Llamar a fork dos veces; . Los programas 8-5 logran esto.
3) Utilice waitpid para esperar a que regrese el proceso hijo.
=======================. ======= ================
El proceso zombie es un proceso zombie. Una forma de evitarlo es utilizar funciones como esperar y esperarpid para obtener el estado de terminación del proceso para liberar recursos. El otro se bifurca dos veces
======================================= == ======
El proceso difunto solo tiene un registro en la tabla de procesos y otros recursos no están ocupados, a menos que casi se haya excedido el límite en la cantidad de procesos en su sistema. el proceso zombie no tendrá más desventajas.
Quizás la única forma sea reiniciar el sistema para eliminar el proceso zombie.
============================================ =
Cualquier programa tiene un estado zombie y ocupa algunos recursos de memoria (es decir, todavía hay un registro en la tabla de procesos. Es solo un síntoma y no hay que tener miedo). Si hay un problema con el programa y tienes la posibilidad de encontrarlo, la forma sencilla y efectiva de resolver una gran cantidad de zombies es reiniciarlo. Kill no tiene efecto
fork and zombie/defunct"
La forma en que operan algunos procesos en Unix. Cuando un proceso muere, no desaparece por completo. El proceso termina, ya no ya no se ejecuta, pero hay algunas cosas residuales esperando a que el proceso padre se recupere. Estas cosas residuales incluyen el valor de retorno del proceso hijo y otras cosas que debe tener después de que el proceso padre bifurca () un proceso hijo. waitpid() para esperar a que salga el proceso hijo. Es esta acción de esperar() la que hace que desaparezcan los restos del proceso hijo.
Naturalmente, existe una excepción a las reglas anteriores: el proceso padre. El software SIGCLD se puede ignorar sin esperar() haciendo esto (en sistemas que lo admiten, como Linux):
main()
{
fork( );
fork();
fork(); /* Conejos, conejos, conejos */
｝
¡Ahora, el El proceso principal no espera () cuando el proceso secundario muere, generalmente puede ver que se muestra como "" usando ps. Permanecerá así hasta que el proceso principal espere (), o lo manejará de la siguiente manera
<. p> Aquí hay otra regla que debe conocer: cuando el proceso padre muere antes de esperar al hijo (asumiendo que no ignora SIGCLD), el hijo tratará el proceso init(pid 1) como su padre. Funciona bien. y es controlable, por lo que no es un problema, pero si el proceso hijo ya está inactivo, tenemos un pequeño problema. Mira, el proceso padre original ya no puede esperar() porque ha muerto. () ¿Estos procesos zombies?Respuesta: Impredecible. En algunos sistemas, init destruye periódicamente todos sus procesos inactivos. En otros sistemas, simplemente se niega a convertirse en un zombie. inmediatamente Si usa uno de los sistemas anteriores, puede escribir un bucle simple que llene la tabla de procesos con procesos inactivos que pertenecen a init. Esto probablemente no molestará a su administrador del sistema. tarea: asegúrese de que su proceso principal no ignore SIGCLD y no espere() para bifurcar() todos los procesos. Sin embargo, no es necesario que haga esto siempre (por ejemplo, debe iniciar un demonio o algo así), pero sí lo ha hecho. Tenga cuidado con la programación si es nuevo en fork(). Además, no tenga limitaciones psicológicas.
Resumen:
El proceso hijo deja de funcionar hasta que el proceso padre espera(), a menos que el proceso padre ignore SIGCLD.
Además, los procesos secundarios (activos o inactivos) cuyo proceso principal muere sin esperar() (aún asumiendo que el proceso principal no ignora SIGCLD) se convierten en hijos de init, e init los maneja de manera pesada. .