异步清理子进程

时间:2014-10-16 16:55:33

标签: c++ process signals

这是来自< Advanced Linux Programming>,第3.4.4章的示例。程序fork()和exec()是一个子进程。我希望父进程能够异步清理子进程(否则子进程将成为一个僵尸进程),而不是等待进程的终止。可以使用信号SIGCHLD完成。通过设置signal_handler,我们可以在子进程结束时完成清理工作。代码如下:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>
#include <string.h>

int spawn(char *program, char **arg_list){
    pid_t child_pid;

     child_pid = fork();
     if(child_pid == 0){    // it is the child process
        execvp(program, arg_list);
        fprintf(stderr, "A error occured in execvp\n");
        return 0;
     }
     else{
        return child_pid;
     }
}

int child_exit_status;

void clean_up_child_process (int signal_number){
    int status;
    wait(&status);
    child_exit_status = status;     // restore the exit status in a global variable
    printf("Cleaning child process is taken care of by SIGCHLD.\n");
};

int main()
{
    /* Handle SIGCHLD by calling clean_up_process; */
    struct sigaction sigchld_action;
    memset(&sigchld_action, 0, sizeof(sigchld_action));
    sigchld_action.sa_handler = &clean_up_child_process;
    sigaction(SIGCHLD, &sigchld_action, NULL);

    int child_status;
    char *arg_list[] = {    //deprecated conversion from string constant to char*
        "ls", 
        "-la",
        ".",
        NULL
    };

    spawn("ls", arg_list);

    return 0;
}

但是,当我在终端中运行程序时,父进程永远不会结束。而且它似乎没有执行函数clean_up_child_process(因为它没有打印出“清洁子进程由SIGCHLD处理。”)。这段代码有什么问题?

3 个答案:

答案 0 :(得分:2)

父进程从main()返回子pid后立即从fork()返回,它永远没有机会等待孩子终止。

答案 1 :(得分:0)

我使用Mac,所以我的答案可能不太相关,但仍然如此。我编译时没有任何选项,因此可执行文件名为a.out

我对控制台有相同的体验(过程似乎没有终止),但我注意到它只是终端故障,因为你实际上可以按Enter键,你的命令行将是返回,实际上从其他终端窗口执行的ps并未显示a.out,也没有显示ls

此外,如果我运行./a.out >/dev/null,它会立即完成。

所以上述观点是一切都实际终止,只是终端因某种原因冻结。

接下来,为什么它永远不会打印Cleaning child process is taken care of by SIGCHLD.。仅仅因为父进程在子进程之前终止。 SIGCHLD信号无法传递到已经终止的进程,因此永远不会调用处理程序。

在书中,它表示父进程会继续执行其他操作,如果确实如此,那么一切正常,例如,如果您在sleep(1)之后添加spawn()

答案 2 :(得分:0)

适用于GNU / Linux用户

我已经读过这本书了。虽然这本书把这个机制称为:

引自本书3.4.4第59页:

  

更优雅的解决方案是在孩子终止时通知父进程。

但它只是说你可以使用sigaction来处理这种情况。

以下是如何以这种方式处理流程的完整示例。

首先我们为什么要使用这种机制?好吧,因为我们不想将所有进程同步在一起。

真实示例
想象一下,您有10个.mp4个文件,并且您希望将它们转换为.mp3个文件。好吧,我初级用户这样做:

ffmpeg -i 01.mp4 01.mp3 

并重复此命令10次。稍高的用户会这样做:

ls *.mp4 | xargs -I xxx ffmpeg -i xxx xxx.mp3

这一次,这个命令管道每行10 mp4个文件,每个一个一个xargs,然后他们一个一个转换为mp3

但我高级用户执行此操作:

ls *.mp4 | xargs -I xxx -P 0 ffmpeg -i xxx xxx.mp3

这意味着如果我有10个文件,请创建 10个进程并同时运行它们。并且 BIG 不同。在之前的两个命令中,我们只有一个进程;它被创建然后终止然后继续到另一个。但是在-P 0选项的帮助下,我们同时创建了10个进程,实际上有10个ffmpeg命令正在运行。

现在异步清理孩子的目的变得更加清晰。事实上,我们想要运行一些新流程,但这些流程的顺序以及它们的退出状态对我们来说无关紧要。通过这种方式,我们可以尽快运行它们并缩短时间。

首先,您可以查看man sigaction以了解您想要的更多详细信息。

第二次看到这个信号编号:

T ❱ kill -l | grep SIGCHLD
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP

示例代码

目标:使用SIGCHLD清理子进程

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <wait.h>
#include <unistd.h>

sig_atomic_t signal_counter;

void signal_handler( int signal_number )
{
    ++signal_counter;
    int wait_status;
    pid_t return_pid = wait( &wait_status );
    if( return_pid == -1 )
    {
        perror( "wait()" );
    }
    if( WIFEXITED( wait_status ) )
    {
        printf ( "job [ %d ] | pid: %d | exit status: %d\n",signal_counter, return_pid, WEXITSTATUS( wait_status ) );
    }
    else
    {
        printf( "exit abnormally\n" );
    }

    fprintf( stderr, "the signal %d was received\n", signal_number );
}

int main()
{
    // now instead of signal function we want to use sigaction
    struct sigaction siac;

    // zero it
    memset( &siac, 0, sizeof( struct sigaction ) );

    siac.sa_handler = signal_handler;
    sigaction( SIGCHLD, &siac, NULL );

    pid_t child_pid;

    ssize_t read_bytes = 0;
    size_t  length = 0;
    char*   line = NULL;

    char* sleep_argument[ 5 ] = { "3", "4", "5", "7", "9" };

    int counter = 0;

    while( counter <= 5 )
    {
        if( counter == 5 )
        {
            while( counter-- )
            {
                pause();
            }

            break;
        }

        child_pid = fork();

        // on failure fork() returns -1
        if( child_pid == -1 )
        {
            perror( "fork()" );
            exit( 1 );
        }

        // for child process fork() returns 0
        if( child_pid == 0 ){
            execlp( "sleep", "sleep", sleep_argument[ counter ], NULL );
        }

        ++counter;
    }

    fprintf( stderr, "signal counter %d\n", signal_counter );

    // the main return value
    return 0;
}

这是示例代码的作用:

  1. 创建5个子进程
  2. 然后进入内部循环并暂停接收信号。请参阅man pause
  3. 然后当孩子终止时,父进程会唤醒并调用signal_handler函数
  4. 继续到最后一个:sleep 9
  5. 输出:(17表示SIGCHLD

    ALP ❱ ./a.out 
    job [ 1 ] | pid: 14864 | exit status: 0
    the signal 17 was received
    job [ 2 ] | pid: 14865 | exit status: 0
    the signal 17 was received
    job [ 3 ] | pid: 14866 | exit status: 0
    the signal 17 was received
    job [ 4 ] | pid: 14867 | exit status: 0
    the signal 17 was received
    job [ 5 ] | pid: 14868 | exit status: 0
    the signal 17 was received
    signal counter 5
    

    运行此示例代码时,在另一个终端上尝试:

    ALP ❱ ps -o time,pid,ppid,cmd --forest -g $(pgrep -x bash)
        TIME   PID  PPID CMD
    00:00:00  5204  2738 /bin/bash
    00:00:00  2742  2738 /bin/bash
    00:00:00  4696  2742  \_ redshift
    00:00:00 14863  2742  \_ ./a.out
    00:00:00 14864 14863      \_ sleep 3
    00:00:00 14865 14863      \_ sleep 4
    00:00:00 14866 14863      \_ sleep 5
    00:00:00 14867 14863      \_ sleep 7
    00:00:00 14868 14863      \_ sleep 9
    

    正如您所看到的,a.out进程有5个孩子。它们同时运行。然后每当每个终止时,内核会将信号SIGCHLD发送给他们的父母:a.out

    注意

    如果我们不使用pause或任何机制,以便可以为其子女wait,那么我们将放弃创建的流程和新贵(= Ubuntuinit)成为他们的父母。如果您删除pause()

    ,可以尝试使用它