Процесс зомби против сиротского процесса

Процесс зомби против сиротского процесса

19.12.2013 10:24:23 Просмотров 27 Источник

Зомби создается, когда родительский процесс не использует системный вызов wait после смерти ребенка, чтобы прочитать его состояние выхода, а сирота-это дочерний процесс, который восстанавливается init, когда исходный родительский процесс завершается раньше дочернего.

С точки зрения управления памятью и таблицей процессов, как эти процессы обрабатываются по-разному, особенно в UNIX?

Каков пример или крайний случай, когда создание зомби или сирот может нанести ущерб большому приложению или системе?

У вопроса есть решение - Посмотреть?

https://stackoverflow.com/questions/20688982/zombie-process-vs-orphan-process#comment30983730_20688982
создайте много зомби и следите за своей системой sssllooooowwww
https://stackoverflow.com/questions/20688982/zombie-process-vs-orphan-process#comment30983794_20688982
Нет никаких причин для зомби-процесса потреблять (нетривиальный объем) памяти... он мертв. Это в основном заполнитель, так что родитель все еще может прочитать статус выхода в какой-то момент в будущем.
https://stackoverflow.com/questions/20688982/zombie-process-vs-orphan-process#comment30983843_20688982
Зомби не занимает никакой значительной памяти или ресурсов, это (фактически) только статус выхода, ожидающий доставки. Сирота-это такой же живой, запущенный процесс, как и любой другой, просто у него есть особое название.
https://stackoverflow.com/questions/20688982/zombie-process-vs-orphan-process#comment30984118_20688982
@clintp но сирота не может стать зомби-процессом, так как ОС будет обрабатывать его после завершения?
https://stackoverflow.com/questions/20688982/zombie-process-vs-orphan-process#comment70249496_20688982
"сирота-это детский процесс, который восстанавливается ", так что это больше не сирота! И поскольку процесс всегда восстанавливается после смерти родителя, то сироты никогда не бывает.

Ответы - Процесс зомби против сиротского процесса / Zombie process vs Orphan process

alk

19.12.2013 11:08:45

  1. Нет никаких сирот, кроме процесса, использующего PID 1.

    С точки зрения запущенного процесса не имеет значения, был ли он запущен непосредственно и, следовательно, имеет PID 1 в качестве родителя или унаследован PID 1, потому что его исходный родитель (отличающийся от PID 1) закончился. Он обрабатывается, как и любой другой процесс.

  2. Каждый процесс проходит через своего рода зомби-состояние, когда он заканчивается, а именно фазу между объявлением о его завершении путем выпуска SIGCHLDи признанием его обработки (доставки или незнания).

Когда состояние зомби было введено, процесс - это просто запись в списке процессов системы.

Единственным значимым ресурсом зомби исключительно с помощью является допустимым идентификатором.

Является ответом!
Rob Napier

19.12.2013 11:13:08

Когда дочерний процесс завершает работу, какой-то процесс должен waitего, чтобы получить код завершения. Этот код выхода хранится в таблице процессов до тех пор, пока это не произойдет. Акт чтения этого кода выхода называется "пожатием" ребенка. Между тем, как ребенок выходит и пожинается, его называют зомби. (Вся эта номенклатура выглядит немного отвратительно, когда вы думаете об этом; я рекомендую не думать об этом слишком много.)

Зомби занимают только место в таблице процессов. Они не берут ни памяти, ни процессора. Однако таблица процессов-это конечный ресурс, и избыточные зомби могут заполнить ее, а это означает, что никакие другие процессы не могут запуститься. Кроме того, они представляют собой надоедливый беспорядок, и их следует всячески избегать.

Если процесс завершается с детьми, которые все еще работают (и не убивают своих детей; метафора продолжает быть странной), эти дети-сироты. Дети-сироты немедленно "усыновляются" init(на самом деле, я думаю, что большинство людей называют это "перевоспитанием", но "усыновление", кажется, лучше переносит метафору). Сирота-это просто процесс. Он будет использовать любые ресурсы, которые он использует. Разумно сказать, что это вовсе не "сирота", поскольку у него есть родитель, но я часто слышал, как их так называют.

initавтоматически пожинает своих детей (усыновленных или нет). Так что если вы выйдете, не убрав своих детей, то они не станут Зомби (по крайней мере, не более чем на мгновение).

Но долгоживущие зомби существуют. Что это такое? Они-бывшие дети существующего процесса, который не пожинал их. Процесс может быть приостановлен. Или же она плохо написана и забывает пожинать плоды своих детей. Или, может быть, он перегружен и до него еще не дошло. Или еще что-нибудь. Но по какой-то причине родительский процесс продолжает существовать (так что они не сироты), и их никто не обслуживал, поэтому они живут как зомби в таблице процессов.

Так что если вы видите зомби дольше, чем на мгновение, то это означает, что с родительским процессом что-то не так, и что-то нужно сделать, чтобы улучшить эту программу.

opticod

14.09.2016 11:25:29

Когда процесс завершается, его ресурсы освобождаются операционной системой. система. Однако его запись в таблице процессов должна оставаться там до тех пор, пока Родительский вызов wait (), так как таблица process содержит статус завершения процесса. Процесс, который завершился, но чей родитель еще не вызвал wait (), является известный как процесс зомби . Все процессы переходят в это состояние, когда они кончаются, но в целом они существуют как зомби лишь недолго. Однажды родитель вызывает wait (), идентификатор процесса зомби-процесса и его запись в поле таблица процессов освобождается.

Теперь рассмотрим, что произойдет, если родитель не вызовет wait () и вместо этого прекращается, тем самым оставляя свои дочерние процессы сиротами . Линукс и UNIX решает этот сценарий, назначая процесс init в качестве нового родителя для бесхозных процессов. Процесс init периодически вызывает wait(), что позволяет статус выходе все потерянные процесса собрал и выпустил идентификатор процесса сироты и запись таблицы процессов.

Источник: концепции операционных систем Авраама, Питера, Грега

https://stackoverflow.com/questions/20688982/zombie-process-vs-orphan-process/39499087#comment68347025_39499087
Очень понравился этот короткий и четкий ответ.
https://stackoverflow.com/questions/20688982/zombie-process-vs-orphan-process/39499087#comment70249110_39499087
Так что на самом деле сирот нет, так как их усыновляют.
Linkon

17.02.2017 08:02:09

Сиротский процесс-это компьютерный процесс, parent processкоторого завершен или завершен, хотя он (дочерний процесс) остается запущенным сам.
Зомби-процесс или несуществующий процесс - это процесс, который завершил выполнение, но все еще имеет запись в таблице процессов, поскольку его родительский процесс не вызывал wait().

SAURABH DUBEY

20.03.2019 04:09:31

Процесс, который завершил выполнение, но все еще имеет запись в таблице процессов, чтобы отчитаться перед своим родительским процессом, известен как зомби-процесс. Процесс, родительский процесс которого больше не существует, то есть либо завершен, либо завершен, не дожидаясь завершения дочернего процесса, называется сиротским процессом.

omkar

05.10.2019 01:31:54

Сирота - Родительский выход, процесс Init становится родителем дочернего процесса. Таким образом, дочерний процесс завершается, и таблица процессов удаляется ОС.

Зомби - Когда ребенок завершает работу, он дает статус выхода родителю. Между тем, предположим, что ваш родитель находится в состоянии сна. Хотя дочерний выход, но процесс занимает место в таблице процессов

проверьте эту команду в ubuntups -эо Линукс идентификатор процесса,идентификатор,статус,УМК Если вы нашли что-то вроде defunc, то есть ваш процесс зомби и занимает пространство

Justice Bringer

25.01.2020 10:33:09

Я хотел бы добавить 2 фрагмента кода с изображением сироты и зомби-процесса. Но сначала я опубликую определение этих процессов, изложенное в книге "концепции операционных систем" Зильбершаца, Галвина и Гагна:

Если нет родительского ожидания (не вызывал wait ()) процесс является зомби

Если родитель завершается без вызова wait, процесс является сиротой

Сирота

// 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; 
}

Выход

Я закончил казнь раньше моего ребенка.

Зомби

// 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; 
} 

Выход

Мой родитель не ждет меня.

Я не жду своего ребенка.

Закрыть X