| dbo:abstract
|
- Un procés zombi en sistemes operatius Unix i similars, (zombie process o defunct process) és un procés que ha completat la seva execució però que encara té una entrada a la . Aquesta entrada és encara necessària per a permetre que el procés que va engegar el que ara és zombi n'obtingui l'estat d'acabament. El terme procés zombi deriva de la definició comú de zombi (una persona no-morta). Seguint amb la metàfora, el procés fill ha mort però no ha estat enterrat. Quan un procés acaba, tota la memòria i els recursos associats amb ell són alliberats, pel que poden ésser usats per altres processos. De totes maneres, l'entrada corresponent al procés a la taula de processos segueix existint. El procés pare pot obtenir la condició de finalització del fill emprant la crida al sistema wait, moment en què s'eliminarà el procés zombi. La crida al sistema wait es pot executar des d'un codi seqüencial, però normalment s'executa en el gestor del senyal SIGCHLD, que el procés pare rep quan mor un dels seus fills. Després d'eliminar el procés zombi de la taula de processos, el seu ID de procés i la seva entrada a la taula poden ésser reutilitzats. Però si un procés pare no cridés a wait o es produís un error, el procés zombi es quedaria a la taula de processos. Hi ha algunes situacions en què això pot resultar interessant. Per exemple, si el pare ha de crear un altre procés fill, d'aquesta manera s'asseguraria que no se li assignés el mateix ID. Com a cas especial, a Linux, si el pare ignora explícitament el senyal SIGCHLD (posa com a gestor SIG_IGN en lloc d'ignorar el senyal, tal com es fa per defecte), tota la informació de sortida dels processos fills serà descartada i no es crearan processos zombi. Un procés zombi no és el mateix que un . Un procés orfe és un procés que està encara en execució, però que el seu pare ha mort. En lloc de convertir-se en un procés zombi, aquest fill serà adoptat per init (ID de procés 1), que fa waits sobre els seus fills. Els zombis poden ésser identificats a la sortida de la comanda d'Unix ps per la presència d'una "Z" a la columna STAT. Els zombis que existeixen durant més d'un període curt de temps solen indicar una falla (un bug) al programa pare. Tal com succeeix amb altres pèrdues, la presència d'uns quants zombis no és preocupant, però pot indicar un problema que serà seriós sota grans càrregues del sistema. Donat que no hi ha memòria reservada per als processos zombis, sinó només una entrada a la taula de processos, el principal problema degut a l'existència de molts processos zombi no és l'esgotament de la memòria, sinó el que s'acabin els ID disponibles per als processos. Per a eliminar zombis d'un sistema, es pot enviar el senyal SIGCHLD manualment al procés pare mitjançant la comanda kill. Si, tot i això, el procés pare no els enterra convenientment, caldrà eliminar el procés pare. Quan un procés perd el seu pare, init esdevé el seu nou pare. init executa periòdicament la crida al sistema wait per a enterrar qualsevol procés zombi que el tingui com a pare. (ca)
- Zombie proces je na Unixových systémech takový proces, který se ukončil (prostřednictvím systémového volání <a href="/wiki/Exit_(syst%C3%A9mov%C3%A9_vol%C3%A1n%C3%AD)" title="Exit (systémové volání)">exit</a>), ale i nadále se vyskytuje v tabulce procesů. Jedná se o proces se statusem terminated (v češtině ukončený). Tato situace nastává u procesů založených jako potomky jiného, již existujícího, procesu, protože u těchto procesů je záznam v tabulce procesů stále třeba, aby si rodičovský proces mohl přečíst návratový kód potomka. Jakmile tak učiní prostřednictvím systémového volání <a href="/wiki/Wait_(syst%C3%A9mov%C3%A9_vol%C3%A1n%C3%AD)" title="Wait (systémové volání)">wait</a>, operační systém odebere záznam z tabulky procesů a uvolní jemu přidělené prostředky. Potomek se vždy napřed stane zombie procesem předtím, než je z tabulky procesů odebrán. Za normálních okolností okamžitě poté, co se potomek stane zombie procesem jeho rodič spustí volání wait a operačnímu systému je takto dán signál, že může proces vymazat. Procesy, které patří mezi zombie procesy delší dobu jsou obvykle chybou a způsobují únik prostředků. Termín zombie proces pochází z běžné definice slova zombie — nemrtvá osoba. V tomto kontextu proces „zemřel“, ale ještě nebyl „uklizen“. Na rozdíl od normálních procesů nemá příkaz <a href="/wiki/Kill_(Unix)" title="Kill (Unix)">kill</a> na zombie procesy žádný efekt. Zombie procesy si není možné plést s osiřelými procesy; osiřelý proces je proces, který se stále provádí, ale jeho rodič zemřel. Tyto procesy nezůstávají jako zombie procesy, namísto toho jsou adoptovány procesem init a ten na své potomky spustí wait. (cs)
- Als Zombie-Prozess wird bei unixartigen Betriebssystemen der Prozesstabelleneintrag eines beendeten Prozesses bezeichnet. Ein beendeter Prozess wird aus der Prozesstabelle entfernt, sobald sein Elternprozess dessen Exit-Status abfragt. Bis dahin verbleibt er dort als Zombie, der keine weiteren Ressourcen außer dem Tabelleneintrag, der Prozess-ID und Einträgen in Nutzungs-Statistiken mehr belegt. Aus unten genauer beschriebenen Gründen bei der Prozessverwaltung wird ein beendeter Prozess manchmal nicht aus der Prozesstabelle entfernt (und belegt somit geringfügige Systemressourcen). Ein solcher, langlebiger Zombie richtet selbst keinen Schaden an, kann aber ein Hinweis auf einen Fehler sein. (de)
- En sistemas operativos Unix, un proceso zombi o "defunct" (difunto) es un proceso que ha completado su ejecución pero aún tiene una entrada en la tabla de procesos, lo que permite al proceso que lo ha creado leer el estado de su salida. Metafóricamente, el proceso hijo ha muerto pero su "alma" aún no ha sido recogida. Cuando un proceso acaba, toda la memoria y recursos asociados se desreferencian, para que puedan ser usados por otros procesos. De todas formas, la entrada del proceso en la tabla de procesos aún permanece. Al padre se le envía una señal SIGCHLD indicando que el proceso ha muerto; el manejador para esta señal será típicamente ejecutar la llamada al sistema wait, que lee el estado de salida y borra al zombi. El ID del proceso zombi y la entrada en la tabla de procesos pueden volver a usarse. Un proceso zombi no es lo mismo que un proceso huérfano. Los procesos huérfanos no se convierten en procesos zombis, sino que son adoptados por init (ID del proceso = 1), que espera a su hijo. El término zombi deriva de la definición común del término. Los zombis pueden ser identificados en la salida por pantalla del comando de Unix ps por la presencia de una Z en la columna de estado. Los zombis pueden existir por un corto período, que típicamente significa un error en el programa padre (un bug). Igualmente, la presencia de muchos procesos zombi puede indicar problemas en el sistema y puede acarrear una alta carga del sistema, lentitud y respuestas lentas. (es)
- Un processo zombie (processo defunto) nei sistemi operativi Unix e Unix-like è un processo informatico che, nonostante abbia terminato la propria esecuzione, possiede ancora un PID ed un Process control block, necessario per permettere al proprio processo padre di leggerne il valore di uscita. (it)
- En informatique, sous les systèmes de type UNIX et similaires, zombie (on utilise plutôt l'orthographe anglaise) est un terme désignant un processus qui s'est achevé, mais qui dispose toujours d'un identifiant de processus (PID) et reste donc encore visible dans la table des processus. On parle aussi de processus défunt (en anglais "defunct"). Au moment de la terminaison d'un processus, le système désalloue les ressources que possède encore le processus mais ne détruit pas son bloc de contrôle. Le système passe ensuite l'état du processus à la valeur TASK_ZOMBIE (représenté généralement par un Z dans la colonne « statut » lors du listage des processus par la commande <a href="/wiki/Ps_(Unix)" title="Ps (Unix)">ps</a>). Le signal SIGCHLD est alors envoyé au du processus qui s'est terminé, afin de l'informer de ce changement. Dès que le processus père a obtenu le code de fin du processus achevé au moyen des appels systèmes wait ou waitpid, le processus terminé est définitivement supprimé de la table des processus. Il existe un bug classique dans le développement de programme UNIX gérant plusieurs processus : un processus qui crée des fils, mais n'attend pas leurs valeurs de retours. Ces fils restent donc sous forme de zombies pendant (au moins) toute la durée d'exécution du processus père. Étant donné que les processus zombies ne peuvent pas être supprimés par les méthodes classiques (y compris pour les utilisateurs privilégiés), le système se retrouve alors encombré de processus achevés (« morts ») mais encore visibles. Ceux-ci ne consomment, à proprement parler, pas plus de ressources systèmes que les quelques octets de mémoire occupés par le bloc de contrôle dans la table des processus ; toutefois, le nombre de processus étant limité par le nombre possible de PID, un trop grand nombre de zombies peut empêcher le système de créer de nouveaux processus. Cette métaphore de horde de processus défunts, impossibles à tuer car déjà morts, est à l'origine du terme de « zombie ». La seule manière d'éliminer ces processus zombies est de causer la mort du processus père, par exemple au moyen du signal <a href="/wiki/SIGKILL" title="SIGKILL">SIGKILL</a>. Les processus fils sont alors automatiquement rattachés au processus n°1, généralement <a href="/wiki/Init" title="Init">init</a>, qui se charge à la place du père original d'appeler wait sur ces derniers. Si ce n'est pas le cas, cela signifie que init est défaillant (ou que le processus n°1 n'est pas init, mais un autre programme n'ayant pas été prévu pour ça) ; le seul moyen de se débarrasser des zombies, dans ce cas, est le redémarrage du système. (fr)
- On Unix and Unix-like computer operating systems, a zombie process or defunct process is a process that has completed execution (via the <a href="/wiki/Exit_(system_call)" title="Exit (system call)">exit</a> system call) but still has an entry in the process table: it is a process in the "Terminated state". This occurs for the child processes, where the entry is still needed to allow the parent process to read its child's exit status: once the exit status is read via the <a href="/wiki/Wait_(system_call)" title="Wait (system call)">wait</a> system call, the zombie's entry is removed from the process table and it is said to be "reaped". A child process always first becomes a zombie before being removed from the resource table. In most cases, under normal system operation zombies are immediately waited on by their parent and then reaped by the system – processes that stay zombies for a long time are generally an error and cause a resource leak, but the only resource they occupy is the process table entry – process ID. The term zombie process derives from the common definition of zombie — an undead person. In the term's metaphor, the child process has "died" but has not yet been "reaped". Also, unlike normal processes, the <a href="/wiki/Kill_(command)" title="Kill (command)">kill</a> command has no effect on a zombie process. Zombie processes should not be confused with orphan processes: an orphan process is a process that is still executing, but whose parent has died. When the parent dies, the orphaned child process is adopted by <a href="/wiki/Init" title="Init">init</a> (process ID 1). When orphan processes die, they do not remain as zombie processes; instead, they are waited on by init. The result is that a process that is both a zombie and an orphan will be reaped automatically. (en)
- Em sistemas operativos Unix um processo zombie é um processo que já foi completamente executado mas ainda se encontra na tabela de processos do sistema operativo, permitindo o processo que o criou ler o seu valor de saída. Quando um processo termina, a memória a ele associada é libertada, no entanto a informação sobre esse processo continua disponível, embora ele já não exista. Normalmente os processos zombie não duram muito tempo já que o sinal é emitido quando ele entra nesse estado, possibilitando ao saber quando isso acontece para ler as informações necessárias. (pt)
- Proces zombie – wpis w tablicy procesów opisujący program, którego wykonanie w systemie operacyjnym zostało zakończone, ale którego zamknięcie nie zostało jeszcze obsłużone przez proces rodzica. Termin ten odnosi się zazwyczaj do systemów z rodziny Unix, gdzie pozostawienie wpisu zombie tymczasowo zajmującego pozycję w tablicy procesów zapobiega ponownemu wykorzystaniu danego PID-a i możliwym na skutek tego pomyłkom programistycznym. Wpisy takie nie dają się wyeliminować poleceniem kill, czemu prawdopodobnie zawdzięczają swoją złowrogą nazwę. Wpis zombie znika po odpowiednim wywołaniu funkcji wait, waitpid lub analogicznej przez proces macierzysty. W przypadku zakończenia także procesu rodzica, w wielu architekturach pozostawione przez niego zombie są obsługiwane automatycznie przez proces init lub przez system operacyjny. W pierwszym przypadku taki wpis zostaje przypisany jako dziecko procesu init, który następnie wywołuje wait, eliminując go z tablicy procesów. Chociaż wpisy zombie nie obciążają znacząco komputera, nieprawidłowo napisany program, który nie obsługuje zakończenia pracy potomków, może doprowadzić do destabilizacji pracy systemu. Dzieje się tak, gdy cała tablica procesów, zwykle posiadająca z góry ograniczony rozmiar, zostanie zajęta przez wpisy zombie. Hierarchia powiadamiania o procesach zombie może zostać czasowo zmieniona przez mechanizm , czasem prowadząc do utrudnień przy debuggowaniu programów. (pl)
- Проце́сс-зо́мби, зо́мби (англ. zombie process, англ. defunct process) — дочерний процесс в Unix-системе, завершивший своё выполнение, но ещё присутствующий в списке процессов операционной системы, чтобы дать родительскому процессу считать код завершения. (ru)
- В Unix-подібних системах процес-зомбі (часто позначається, як defunct) — це процес, що завершив виконання, але все ще має запис в таблиці процесів. Цей запис потрібен, щоб батьківський процес міг прочитати . Термін процес-зомбі походить із загального визначення людини-зомбі. За цією метафорою процес-нащадок помер, але ще не був забраний смертю. На відміну від нормальних процесів, команда kill ніяк не впливає на процес-зомбі. Коли процес завершується, вся пам’ять і пов’язані з ним ресурси звільняються для інших процесів, проте, запис процесу залишається в таблиці процесів. Батьківський процес може прочитати за допомогою системного виклику <a href="/wiki/Wait" title="Wait">wait</a>, після чого процес-зомбі буде прибрано зі списку процесів. Виклик wait може бути зроблено послідовно, але зазвичай його виконують в обробнику подій для SIGCHLD, який отримує батьківський процес, коли нащадок завершується. (uk)
- 在类UNIX系统中，僵尸进程是指完成执行（通过<a href="/w/index.php?title=Exit_(Unix)&action=edit&redlink=1" class="new" title="Exit (Unix)（页面不存在）">exit</a>系统调用，或运行时发生致命错误或收到终止信号所致），但在操作系统的进程表中仍然存在其进程控制块，处于""的进程。这发生于子进程需要保留表项以允许其父进程读取子进程的退出狀態：一旦退出态通过<a href="/wiki/Wait_(Unix)" title="Wait (Unix)">wait</a>系统调用读取，僵尸进程条目就从进程表中删除，称之为"回收"（reaped）。正常情况下，进程直接被其父进程wait并由系统回收。进程长时间保持僵尸状态一般是错误的并导致资源泄漏。 英文术语zombie process源自喪屍——不死之人，隐喻子进程已死但仍然没有被回收。与正常进程不同，<a href="/wiki/Kill_(%E5%91%BD%E4%BB%A4)" title="Kill (命令)">kill</a>命令对僵尸进程无效。孤儿进程不同于僵尸进程，其父进程已经死掉，但孤儿进程仍能正常执行，但并不会变为僵尸进程，因为被<a href="/wiki/Init" title="Init">init</a>（进程ID号为1）收养并wait其退出。 子进程死后，系统会发送SIGCHLD信号给父进程，父进程对其默认处理是忽略。如果想响应这个消息，父进程通常在信号事件处理程序中，使用wait系统调用来响应子进程的终止。 僵尸进程被回收后，其进程号与在进程表中的表项都可以被系统重用。但如果父进程没有调用wait，僵尸进程将保留进程表中的表项，导致了资源泄漏。某些情况下这反倒是期望的：父进程创建了另外一个子进程，并希望具有不同的进程号。如果父进程通过设置事件处理函数为SIG_IGN显式忽略SIGCHLD信号，而不是隐式默认忽略该信号，或者具有SA_NOCLDWAIT标志，所有子进程的退出状态信息将被抛弃并且直接被系统回收。 UNIX命令<a href="/wiki/Ps_(Unix)" title="Ps (Unix)">ps</a>列出的进程的状态（"STAT"）栏标示为 "Z"则为僵尸进程。 收割僵尸进程的方法是通过kill命令手工向其父进程发送SIGCHLD信号。如果其父进程仍然拒绝收割僵尸进程，则终止父进程，使得init进程收养僵尸进程。init进程周期执行wait系统调用收割其收养的所有僵尸进程。 为避免产生僵尸进程，实际应用中一般采取的方式是： 1.
* 将父进程中对SIGCHLD信号的处理函数设为SIG_IGN（忽略信号）； 2.
* fork两次并杀死一级子进程，令二级子进程成为孤儿进程而被init所“收养”、清理。 (zh)
|
| rdfs:comment
|
- Un processo zombie (processo defunto) nei sistemi operativi Unix e Unix-like è un processo informatico che, nonostante abbia terminato la propria esecuzione, possiede ancora un PID ed un Process control block, necessario per permettere al proprio processo padre di leggerne il valore di uscita. (it)
- Em sistemas operativos Unix um processo zombie é um processo que já foi completamente executado mas ainda se encontra na tabela de processos do sistema operativo, permitindo o processo que o criou ler o seu valor de saída. Quando um processo termina, a memória a ele associada é libertada, no entanto a informação sobre esse processo continua disponível, embora ele já não exista. Normalmente os processos zombie não duram muito tempo já que o sinal é emitido quando ele entra nesse estado, possibilitando ao saber quando isso acontece para ler as informações necessárias. (pt)
- Проце́сс-зо́мби, зо́мби (англ. zombie process, англ. defunct process) — дочерний процесс в Unix-системе, завершивший своё выполнение, но ещё присутствующий в списке процессов операционной системы, чтобы дать родительскому процессу считать код завершения. (ru)
- Un procés zombi en sistemes operatius Unix i similars, (zombie process o defunct process) és un procés que ha completat la seva execució però que encara té una entrada a la . Aquesta entrada és encara necessària per a permetre que el procés que va engegar el que ara és zombi n'obtingui l'estat d'acabament. El terme procés zombi deriva de la definició comú de zombi (una persona no-morta). Seguint amb la metàfora, el procés fill ha mort però no ha estat enterrat. (ca)
- Zombie proces je na Unixových systémech takový proces, který se ukončil (prostřednictvím systémového volání <a href="/wiki/Exit_(syst%C3%A9mov%C3%A9_vol%C3%A1n%C3%AD)" title="Exit (systémové volání)">exit</a>), ale i nadále se vyskytuje v tabulce procesů. Jedná se o proces se statusem terminated (v češtině ukončený). Tato situace nastává u procesů založených jako potomky jiného, již existujícího, procesu, protože u těchto procesů je záznam v tabulce procesů stále třeba, aby si rodičovský proces mohl přečíst návratový kód potomka. Jakmile tak učiní prostřednictvím systémového volání <a href="/wiki/Wait_(syst%C3%A9mov%C3%A9_vol%C3%A1n%C3%AD)" title="Wait (systémové volání)">wait</a>, operační systém odebere záznam z tabulky procesů a uvolní jemu přidělené prostředky. Potomek se vždy např (cs)
- Als Zombie-Prozess wird bei unixartigen Betriebssystemen der Prozesstabelleneintrag eines beendeten Prozesses bezeichnet. Ein beendeter Prozess wird aus der Prozesstabelle entfernt, sobald sein Elternprozess dessen Exit-Status abfragt. Bis dahin verbleibt er dort als Zombie, der keine weiteren Ressourcen außer dem Tabelleneintrag, der Prozess-ID und Einträgen in Nutzungs-Statistiken mehr belegt. (de)
- En sistemas operativos Unix, un proceso zombi o "defunct" (difunto) es un proceso que ha completado su ejecución pero aún tiene una entrada en la tabla de procesos, lo que permite al proceso que lo ha creado leer el estado de su salida. Metafóricamente, el proceso hijo ha muerto pero su "alma" aún no ha sido recogida. Un proceso zombi no es lo mismo que un proceso huérfano. Los procesos huérfanos no se convierten en procesos zombis, sino que son adoptados por init (ID del proceso = 1), que espera a su hijo. El término zombi deriva de la definición común del término. (es)
- En informatique, sous les systèmes de type UNIX et similaires, zombie (on utilise plutôt l'orthographe anglaise) est un terme désignant un processus qui s'est achevé, mais qui dispose toujours d'un identifiant de processus (PID) et reste donc encore visible dans la table des processus. On parle aussi de processus défunt (en anglais "defunct"). (fr)
- On Unix and Unix-like computer operating systems, a zombie process or defunct process is a process that has completed execution (via the <a href="/wiki/Exit_(system_call)" title="Exit (system call)">exit</a> system call) but still has an entry in the process table: it is a process in the "Terminated state". This occurs for the child processes, where the entry is still needed to allow the parent process to read its child's exit status: once the exit status is read via the <a href="/wiki/Wait_(system_call)" title="Wait (system call)">wait</a> system call, the zombie's entry is removed from the process table and it is said to be "reaped". A child process always first becomes a zombie before being removed from the resource table. In most cases, under normal system operation zombies are immedia (en)
- Proces zombie – wpis w tablicy procesów opisujący program, którego wykonanie w systemie operacyjnym zostało zakończone, ale którego zamknięcie nie zostało jeszcze obsłużone przez proces rodzica. Termin ten odnosi się zazwyczaj do systemów z rodziny Unix, gdzie pozostawienie wpisu zombie tymczasowo zajmującego pozycję w tablicy procesów zapobiega ponownemu wykorzystaniu danego PID-a i możliwym na skutek tego pomyłkom programistycznym. Wpisy takie nie dają się wyeliminować poleceniem kill, czemu prawdopodobnie zawdzięczają swoją złowrogą nazwę. (pl)
- 在类UNIX系统中，僵尸进程是指完成执行（通过<a href="/w/index.php?title=Exit_(Unix)&action=edit&redlink=1" class="new" title="Exit (Unix)（页面不存在）">exit</a>系统调用，或运行时发生致命错误或收到终止信号所致），但在操作系统的进程表中仍然存在其进程控制块，处于""的进程。这发生于子进程需要保留表项以允许其父进程读取子进程的退出狀態：一旦退出态通过<a href="/wiki/Wait_(Unix)" title="Wait (Unix)">wait</a>系统调用读取，僵尸进程条目就从进程表中删除，称之为"回收"（reaped）。正常情况下，进程直接被其父进程wait并由系统回收。进程长时间保持僵尸状态一般是错误的并导致资源泄漏。 子进程死后，系统会发送SIGCHLD信号给父进程，父进程对其默认处理是忽略。如果想响应这个消息，父进程通常在信号事件处理程序中，使用wait系统调用来响应子进程的终止。 UNIX命令<a href="/wiki/Ps_(Unix)" title="Ps (Unix)">ps</a>列出的进程的状态（"STAT"）栏标示为 "Z"则为僵尸进程。 为避免产生僵尸进程，实际应用中一般采取的方式是： (zh)
- В Unix-подібних системах процес-зомбі (часто позначається, як defunct) — це процес, що завершив виконання, але все ще має запис в таблиці процесів. Цей запис потрібен, щоб батьківський процес міг прочитати . Термін процес-зомбі походить із загального визначення людини-зомбі. За цією метафорою процес-нащадок помер, але ще не був забраний смертю. На відміну від нормальних процесів, команда kill ніяк не впливає на процес-зомбі. (uk)
|
