Почему у меня есть `wait()` для дочерних процессов?

Ответ 1

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

Ознакомьтесь с документацией для waitpid. Вы можете сказать waitpid НЕ блокировать (т.е. Немедленно возвращаться, если нет детей, чтобы пожать) с помощью параметра WNOHANG. Кроме того, вам не нужно давать waitpid PID. Вы можете указать -1, и он будет ждать любого дочернего элемента. Поэтому вызов waitpid, как показано ниже, соответствует вашему ограничению без блокировки и ограничению без сохранения-pids:

waitpid( -1, &status, WNOHANG );

Если вы действительно не хотите правильно обрабатывать создание процесса, тогда вы можете передать ответственность за init, дважды нажав, пожиная ребенка и передав exec внуку:

pid_t temp_pid, child_pid;
temp_pid = fork();
if( temp_pid == 0 ){
    child_pid = fork();
    if( child_pid == 0 ){
        // exec()
        error( EXIT_FAILURE, errno, "failed to exec :(" );
    } else if( child_pid < 0 ){
        error( EXIT_FAILURE, errno, "failed to fork :(" );
    }
    exit( EXIT_SUCCESS );
} else if( temp_pid < 0 ){
    error( EXIT_FAILURE, errno, "failed to fork :(" );
} else {
    wait( temp_pid );
}

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

Почему Linux держит зомби вообще? Почему я должен ждать своего дети? Это для обеспечения дисциплины в отношении родительских процессов? В десятилетия использования Linux у меня никогда не было ничего полезного из зомби процессов, я не совсем понимаю полезность зомби как "функции". Если ответ заключается в том, что родительские процессы должны иметь способ узнать что случилось с их детьми, тогда ради бога нет причина считать зомби обычными процессами и запретить создание не зомби-процессы только потому, что слишком много зомби.

Как еще вы предлагаете, можно эффективно получить код выхода процесса? Проблема в том, что отображение кода PID <= > exit (et al.) Должно быть один к одному. Если ядро ​​выпустило PID процесса, как только оно выйдет, будет получено или нет, а затем новый процесс наследует тот же PID и выйдет, как бы вы справились с сохранением двух кодов для одного PID? Как бы заинтересованный процесс извлекал код выхода для первого процесса? Не предполагайте, что никто не заботится о кодах выхода просто потому, что вы этого не делаете. Вы считаете, что это неприятность/ошибка, считаются полезными и чистыми.

В системе, которую я сейчас разрабатываю, я могу создавать только 400-500 перед тем, как все перестанет останавливаться (это плохо поддерживается Система CentOS, работающая на самом дешевом VServer, который я мог найти - но все же 400 зомби меньше, чем несколько килобайт информации)

Нечто похожее на то, чтобы сделать широко распространенное поведение ядра козлом отпущения для явно разочарований в плохо поддерживаемой/дешевой системе, кажется неправильным.

Как правило, максимальное количество процессов ограничено только вашей памятью. Вы можете увидеть свой предел с помощью:

cat /proc/sys/kernel/threads-max

Ответ 2

Ваше рассуждение обратное: ядро ​​держит зомби, потому что они сохраняют состояние, которое вы можете получить с помощью wait() и связанных системных вызовов.

Правильный способ обработки асинхронного дочернего завершения состоит в том, чтобы иметь обработчик SIGCHLD, который выполняет wait() для очистки дочерних процессов.

Ответ 3

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

Ответ 4

Хотя сохранение мертвого pid в таблице процессов в основном для обеспечения его последующего кода для родителя,

Мне приходится жаловаться на то, что там есть дизайн bad (но уже стал историческим и неизменным).

1. Нельзя предварительно объявить, что i_don_care_status_of( pid )

В ОС Windows у нас есть close( processHandle ), чтобы добиться этого эффекта.

HANDLE aProcessHandle = CreateProcess(.....);
CloseHandle( aProcessHandle )

Чтобы преодолеть это, существуют некоторые не совершенные методы (из Wiki):

В современных UNIX-подобных системах (которые соответствуют спецификации SUSv3 в этом отношении) применяется следующий специальный случай: если родитель явно игнорирует SIGCHLD, установив свой обработчик на SIG_IGN (а не просто игнорируя сигнал по умолчанию) или флаг SA_NOCLDWAIT, вся информация о статусе дочернего выхода будет удалена, и никакие процессы зомби не будут оставлены. [1]

2. Нет обработки опорных счетчиков pid.

Когда процесс мертв, если нет ссылки на pid, ядро ​​может немедленно удалить его.

3. Не удается получить код выхода несвязанного pid

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

(Использование NETLINK + PROC_CONNECTOR может прослушивать событие выхода любого асинхронного pid).

В Windows это можно сделать с помощью WaitForSingleObject

HANDLE aProcessHandle = OpenProcess( pid... );
WaitForSingleObject(aProcessHandle, ...);

Эти недостатки, по-видимому, существуют, но дизайн Unix/Linux очень прост, поэтому мы должны его обнажить.

Ответ 5

Чтобы предоставить вам "exitcode" процесса, система должна сохранить для вас "базу данных процесса". Такая база данных с только кодом выхода называется "зомби". Вы можете использовать отдельный процесс, который будет периодически запрашивать "процессы зомби" для их "exitcode", тем самым эффективно освобождая эту память. То же самое можно сказать о Windows и других операционных системах. Linux здесь не особо особенный. Вам не нужно ждать процесса, просто спросите его "код выхода" после завершения процесса.