[apue] 等待子进程的那些事儿
谈到等待子进程,首先想到的就是SIGCHLD信号与wait函数族,本文试图厘清二者的方方面面,以及组合使用时可能不小心掉进去的坑。
1. 首先谈单独使用SIGCHLD的场景。下面是一段典型的代码片段:
#include "../apue.h" #include <sys/wait.h> #define CLD_NUM 2 static void sig_cld (int signo) { pid_t pid = 0; int status = 0; printf ("SIGCHLD received\n"); if (signal (SIGCHLD, sig_cld) == SIG_ERR) perror ("signal error"); if ((pid = wait (&status)) < 0) perror ("wait(in signal) error"); printf ("pid (wait in signal) = %d\n", pid); } int main () { pid_t pid = 0; __sighandler_t ret = signal (SIGCHLD, sig_cld); if (ret == SIG_ERR) perror ("signal error"); else printf ("old handler %x\n", ret); for (int i=0; i<CLD_NUM; ++ i) { if ((pid = fork ()) < 0) perror ("fork error"); else if (pid == 0) { sleep (3); printf ("child %u exit\n", getpid ()); _exit (0); } sleep (1); } for (int i=0; i<CLD_NUM; ++ i) { pause (); printf ("wake up by signal %d\n", i); } printf ("parent exit\n"); return 0; }
父进程启动了两个子进程,在SIGCHLD信号处理器中调用wait等待已结束的子进程,回收进程信息,防止产生僵尸进程(zombie)。上面的代码会有如下的输出:
old handler 0 child 28542 exit SIGCLD received pid (wait in signal) = 28542 wake up by signal 0 child 28543 exit SIGCLD received pid (wait in signal) = 28543 wake up by signal 1 parent exit
当然捕获SIGCHLD,也可以使用sigaction接口:
#include "../apue.h" #include <sys/wait.h> #define CLD_NUM 2 static void sig_cld (int signo, siginfo_t *info, void* param) { int status = 0; if (signo == SIGCHLD) { if (info->si_code == CLD_EXITED || info->si_code == CLD_KILLED || info->si_code == CLD_DUMPED) { //printf ("child %d die\n", info->si_pid); if (waitpid (info->si_pid, &status, 0) < 0) perror ("wait(in signal) error"); printf ("pid (wait in signal) = %d\n", info->si_pid); } else { printf ("unknown signal code %d\n", info->si_code); } } } int main () { pid_t pid = 0; struct sigaction act; sigemptyset (&act.sa_mask); act.sa_sigaction = sig_cld; act.sa_flags = SA_SIGINFO | SA_NOCLDSTOP; int ret = sigaction (SIGCHLD, &act, 0); if (ret == -1) perror ("sigaction error"); for (int i=0; i<CLD_NUM; ++ i) { if ((pid = fork ()) < 0) perror ("fork error"); else if (pid == 0) { sleep (3); printf ("child %u exit\n", getpid ()); _exit (0); } sleep (1); } for (int i=0; i<CLD_NUM; ++ i) { pause (); printf ("wake up by signal %d\n", i); } printf ("parent exit\n"); return 0; }
输出是一样的。
关于signal与sigaction的区别,有以下几点:
a) 使用sigaction可以避免重新安装信号处理器的问题;
b) 使用sigaction可以在wait之前得知是哪个子进程结束了,这是通过指定SA_SIGINFO标志位,并提供带siginfo_t参数的信号处理器来实现的(info->si_pid就是结束的进程号);
c) 使用sigaction可以获取除子进程结束以外的状态变更通知,例如挂起、继续,默认接收相应通知,除非指定SA_NOCLDSTOP标志。而对于signal而言,没有办法不接收子进程非结束状态的通知(此时调用wait可能会卡死);
d) 使用sigaction可以自动wait已结束的子进程,只要指定SA_NOCLDWAIT标志即可。此时在信号处理器中不用再调用wait函数了。
当使用SA_NOCLDWAIT标志位时,使用systemtap可以观察到子进程还是向父进程发送了SIGCHLD信号的:
30049 cldsig 30048 cldsig 17 SIGCHLD 30050 cldsig 30048 cldsig 17 SIGCHLD
很有可能是系统内部自动wait了相关子进程。
另外在使用SA_NOCLDWAIT时,可以不指定信号处理器,此时sa_sigaction字段可以设置为SIG_DFL。
关于SIGCHLD信号,有以下几点需要注意:
a) 如果在注册信号之前,就已经有已结束但未等待的子进程存在,则事件不会被触发;
b) 可以为SIGCHLD注册一个处理器,也可以忽略该信号(SIG_IGN),忽略时系统自动回收已结束的子进程;
当正常捕获SIGCHLD时,使用systemtap是可以观察到子进程向父进程发送的SIGCHLD信号的:
29877 cldsig 29876 cldsig 17 SIGCHLD 29878 cldsig 29876 cldsig 17 SIGCHLD 29876 cldsig 27771 bash 17 SIGCHLD
当忽略SIGCHLD时,是看不到的,只能看到父进程结束时向bash发送的SIGCHLD信号:
29893 cldsig 27771 bash 17 SIGCHLD
这里注意一下二者在细节处的一点区别。
c) 还有一个SIGCLD信号,在大多数unix like系统中与SIGCHLD表现一致,在某些古老的unix系统上,可能有独特的表现需要注意,这方面请参考 apue 第十章第七节
在我测试的环境上(CentOS 6.7),该信号被定义为SIGCHLD,因此是完全相同的;
关于使用信号等待子进程最后需要谈的一点就是信号的竞争行为,对上面的例子稍加修改,就可以演示一下:
#include "../apue.h" #include <sys/wait.h> #define CLD_NUM 2 void pid_remove (pid_t pid) { printf ("remove pid %u\n", pid); } void pid_add (pid_t pid) { printf ("add pid %u\n", pid); } static void sig_cld (int signo) { pid_t pid = 0; int status = 0; printf ("SIGCHLD received\n"); if (signal (SIGCHLD, sig_cld) == SIG_ERR) perror ("signal error"); if ((pid = wait (&status)) < 0) perror ("wait(in signal) error"); printf ("pid (wait in signal) = %d\n", pid); pid_remove (pid); } int main () { pid_t pid = 0; __sighandler_t ret = signal (SIGCHLD, sig_cld); if (ret == SIG_ERR) perror ("signal error"); else printf ("old handler %x\n", ret); for (int i=0; i<CLD_NUM; ++ i) { if ((pid = fork ()) < 0) perror ("fork error"); else if (pid == 0) { //sleep (3); printf ("child %u exit\n", getpid ()); _exit (0); } sleep (1); pid_add (pid); } sleep (1); printf ("parent exit\n"); return 0; }
父进程在启动子进程后需要将它的信息通过pid_add添加到某种数据结构中,当收到SIGCHLD信号后,又通过pid_remove将它从这个数据结构中移出。
在上面的例子中,子进程一启动就退出了,快到甚至父进程还没有来得及执行pid_add就先执行了pid_remove,这必然导致某种问题。
(注意,为了能更好的呈现信号竞争的问题,这里故意在父进程sleep之后调用pid_add),执行结果如下:
old handler 0 child 31213 exit SIGCLD received pid (wait in signal) = 31213 remove pid 31213 add pid 31213 child 31214 exit SIGCLD received pid (wait in signal) = 31214 remove pid 31214 add pid 31214 parent exit
可以看到,remove总是在add之前执行。而解决方案也很直接,就是在pid_add完成之前,我们需要屏蔽SIGCHLD信号:
#include "../apue.h" #include <sys/wait.h> #define CLD_NUM 2 void pid_remove (pid_t pid) { printf ("remove pid %u\n", pid); } void pid_add (pid_t pid) { printf ("add pid %u\n", pid); } static void sig_cld (int signo) { pid_t pid = 0; int status = 0; printf ("SIGCHLD received\n"); if (signal (SIGCHLD, sig_cld) == SIG_ERR) perror ("signal error"); if ((pid = wait (&status)) < 0) perror ("wait(in signal) error"); printf ("pid (wait in signal) = %d\n", pid); pid_remove (pid); } int main () { pid_t pid = 0; __sighandler_t ret = signal (SIGCHLD, sig_cld); if (ret == SIG_ERR) perror ("signal error"); else printf ("old handler %x\n", ret); for (int i=0; i<CLD_NUM; ++ i) { sigset_t mask; sigemptyset(&mask); sigaddset(&mask, SIGCHLD); sigprocmask(SIG_BLOCK, &mask, NULL); if ((pid = fork ()) < 0) perror ("fork error"); else if (pid == 0) { sigprocmask(SIG_UNBLOCK, &mask, NULL); //sleep (3); printf ("child %u exit\n", getpid ()); _exit (0); } sleep (1); pid_add (pid); sigprocmask(SIG_UNBLOCK, &mask, NULL); } sleep (1); printf ("parent exit\n"); return 0; }
这里用到了sigprocmask去屏蔽以及解除某种信号的屏蔽。新的代码运行结果如下:
old handler 0 child 31246 exit add pid 31246 SIGCLD received pid (wait in signal) = 31246 remove pid 31246 child 31247 exit SIGCLD received pid (wait in signal) = 31247 remove pid 31247 add pid 31247 parent exit
可以看到一切正常了,add这次位于remove之前。
总结一下,使用SIGCHLD信号适合异步等待子进程的场景,并且通常搭配wait来回收子进程。
2. 然后谈单独使用wait函数族的场景。典型代码如下:
#include "../apue.h" #include <sys/wait.h> #define CLD_NUM 2 int main () { pid_t pid = 0; for (int i=0; i<CLD_NUM; ++ i) { if ((pid = fork ()) < 0) perror ("fork error"); else if (pid == 0) { sleep (3); printf ("child %u exit\n", getpid ()); _exit (0); } sleep (1); } int status = 0; for (int i=0; i<CLD_NUM; ++ i) { if ((pid = wait (&status)) < 0) perror ("wait error"); printf ("pid = %d\n", pid); } printf ("parent exit\n"); return 0; }
与之前场景不同的是,这里父进程同步等待启动的子进程结束。上面的代码会有如下输出:
child 28583 exit child 28584 exit pid = 28583 pid = 28584 parent exit
关于wait函数族,需要注意以下几点:
a) wait用于等待任何一个子进程,相当于waitpid(-1, status, 0); 当没有任何子进程存在时,返回-1,errno设置为ECHILD;
b) waitpid相对于wait的优势在于:
i) 可以指定子进程(组)来等待;
ii) 可以捕获子进程除结束以外的其它状态变更通知,如挂起(WUNTRACED)、继续(WCONTINUED)等;
iii) 可以不阻塞的测试某个子进程是否已结束(WNOHANG);
c) wait函数族可被信号中断,此时返回-1,errno设置为EINTR,必要时需要重启wait;
总结一下,使用wait函数族适合同步等待子进程,例如某种命令执行器进程,通常配合waitpid来回收子进程。
3. 最后谈谈混合使用同步wait与异步wait函数族的场景。
其实前面已经提到SIGCHLD要搭配wait使用,但那是异步使用wait的单一场景,而这里讲的混合,是指同时在信号处理器与执行流程中使用wait。
例如bash,它除了在主流程中同步等待前台正在运行的子进程,还必需在信号处理器中异步接收后台运行子进程的状态反馈,这样就不得不混合使用wait。
同步等待某个子进程一般使用waitpid,而在信号处理器中一般使用wait,典型的代码如下所示:
#include "../apue.h" #include <sys/wait.h> #include <errno.h> #define CLD_NUM 2 static void sig_cld (int signo) { pid_t pid = 0; int status = 0; printf ("SIGCLD received\n"); if (signal (SIGCLD, sig_cld) == SIG_ERR) perror ("signal error"); if ((pid = wait (&status)) < 0) perror ("wait(in signal) error"); else printf ("pid (wait in signal) = %d\n", pid); } int main () { pid_t pid = 0; __sighandler_t ret = signal (SIGCLD, sig_cld); if (ret == SIG_ERR) perror ("signal error"); else printf ("old handler %x\n", ret); for (int i=0; i<CLD_NUM; ++ i) { if ((pid = fork ()) < 0) perror ("fork error"); else if (pid == 0) { if (i % 2 == 0) { // simulate background sleep (3); } else { // simulate foreground sleep (4); } printf ("child %u exit\n", getpid ()); _exit (0); } sleep (1); } int status = 0; printf ("before wait pid %u\n", pid); if (waitpid (pid, &status, 0) < 0) printf ("wait %u error %d\n", pid, errno); else printf ("wait child pid = %d\n", pid); sleep (2); printf ("parent exit\n"); return 0; }
父进程启动两个子进程,第一个休眠3秒后退出,第二个休眠4秒后退出,由于父进程同步等待的是第二个子进程,因此第二个进程模拟前台进程,第一个进程模拟后台进程。运行输出如下:
old handler 0 before wait pid 2481 child 2480 exit SIGCLD received pid (wait in signal) = 2480 wait 2481 error 4 child 2481 exit SIGCLD received pid (wait in signal) = 2481 parent exit
此时同步等待的waitpid被信号中断了(EINTR),此种情况下,我们需要重启waitpid:
int status = 0; while (1) { printf ("before wait pid %u\n", pid); if (waitpid (pid, &status, 0) < 0) { int err = errno; printf ("wait %u error %d\n", pid, err); if (err == EINTR) continue; } else printf ("wait child pid = %d\n", pid); break; }
如果因EINTR引发的错误,则重新调用waitpid;否则,退出。新的代码输出如下:
old handler 0 before wait pid 2513 child 2512 exit SIGCLD received pid (wait in signal) = 2512 wait 2513 error 4 before wait pid 2513 child 2513 exit SIGCLD received wait(in signal) error: No child processes wait child pid = 2513 parent exit
可以看到两个进程退出时,都收到了SIGCHLD信号,只是前台进程被waitpid优先等待到了,所以信号处理器中的wait返回的ECHILD错误,但是如果还有其它子进程在运行,这里将会在信号处理器的wait中卡死。
之前提到,可以使用SIG_IGN来自动回收子进程,这里试一下使用SIG_IGN来代替sig_cld,看看有什么改观。
old handler 0 before wait pid 2557 child 2556 exit child 2557 exit wait 2557 error 10 parent exit
同样的,两个子进程都走了忽略信号,而同步等待的waitpid因没有进程可等返回了ECHILD。因为waitpid是指定进程等待的,所以即使还有其它子进程存在,这个也会返回错误,不会卡死在那里。
相比上面的方法,似乎好了一点,但是因为我们没有安装处理器,所以无从得知哪个后台进程结束了,这并不是我们想到的结果。
之前提到,可以使用sigaction代替signal以获取更多的控制,我们看看换新的方式捕获信号,会不会有一些改变,新的代码逻辑如下:
#include "../apue.h" #include <sys/wait.h> #include <errno.h> #define CLD_NUM 2 static void sig_cld (int signo, siginfo_t *info, void* param) { int status = 0; if (signo == SIGCHLD) { if (info->si_code == CLD_EXITED || info->si_code == CLD_KILLED || info->si_code == CLD_DUMPED) { if (waitpid (info->si_pid, &status, 0) < 0) err_ret ("wait(in signal) %u error", info->si_pid); else printf ("pid (wait in signal) = %d\n", info->si_pid); } else { printf ("unknown signal code %d\n", info->si_code); } } } int main () { pid_t pid = 0; struct sigaction act; sigemptyset (&act.sa_mask); act.sa_sigaction = sig_cld; act.sa_flags = SA_SIGINFO | SA_NOCLDSTOP; int ret = sigaction (SIGCHLD, &act, 0); if (ret == -1) perror ("sigaction error"); for (int i=0; i<CLD_NUM; ++ i) { if ((pid = fork ()) < 0) perror ("fork error"); else if (pid == 0) { if (i % 2 == 0) { // simulate background sleep (3); } else { // simulate foreground sleep (4); } printf ("child %u exit\n", getpid ()); _exit (0); } sleep (1); } int status = 0; while (1) { printf ("before wait pid %u\n", pid); if (waitpid (pid, &status, 0) < 0) { int err = errno; printf ("wait %u error %d\n", pid, err); if (err == EINTR) continue; } else printf ("wait child pid = %d\n", pid); break; } sleep (2); printf ("parent exit\n"); return 0; }
运行输出如下:
before wait pid 2585 child 2584 exit pid (wait in signal) = 2584 wait 2585 error 4 before wait pid 2585 child 2585 exit wait(in signal) 2585 error: No child processes wait child pid = 2585 parent exit
结果与使用signal很相似,但是因为在信号处理器中我们能明确的知道是哪个子进程终结了,使用的是waitpid而不是wait,所以即使还有其它子进程未结束,也不会在信号处理器的waitpid中卡住。
结论是无论使用signal还是sigaction,同步等待的waitpid总比SIGCHLD信号处理器中的wait(xxx)具有更高的优先级。当然,这个前提是在父进程同步waitpid之前,子进程还没有结束;
如果要等待的子进程先结束了,SIGCHLD当然先被执行,这种情况下,建议先使用sigprocmask屏蔽SIGCHLD信号,然后在waitpid之前解除屏蔽。虽然不能保证完全解决信号竞争的问题,
也能极大的缓解此种情况,即使出现了信号竞争,导致同步等待的waitpid返回ECHILD,我们也能从这些错误码中得知发生的事情,不会出现卡死的情况。
出于好奇,我们看一下改使用SIG_IGN后的运行效果:
before wait pid 2613 child 2612 exit child 2613 exit wait 2613 error 10 parent exit
与使用signal时并无二致,仍然是忽略信号占了上风。结论是无论使用signal还是sigaction,当忽略SIGCHLD信号时,信号优先于wait被忽略。出于同样的原因,这种方式我们并不采纳。
之前提到,sigaction还有一种高级的忽略SIGCHLD的方式,即指定SA_NOCLDWAIT标志位,同时给信号处理器指定SIG_DFL,这种情况下,我们看看输出会有什么变化:
before wait pid 2719 child 2718 exit child 2719 exit wait 2719 error 10 parent exit
可以看到,与使用SIG_IGN并无二致。
与SIG_IGN不同的是,我们可以为SIGCHLD提供一个处理器,虽然在此信号处理器中无需再次等待子进程,但是我们拥有了获取子进程信息的能力,相对而言,比SIG_IGN更有用一些。新的输出如下:
before wait pid 2737 child 2736 exit pid (auto wait in signal) = 2736 wait 2737 error 4 before wait pid 2737 child 2737 exit pid (auto wait in signal) = 2737 wait 2737 error 10 parent exit
可以看到,同步waitpid仍然返回ECHILD,显然是信号更具有优先级。
好了,到这里就全明了了,对于混合使用同步与异步wait的应用来说,最佳的方法应该是同步waitpid等待前台进程,异步使用sigaction注册SIGCHLD信号处理器等待后台进程,且不设置SA_NOCLDWAIT标志位。
在处理器中也应使用waitpid等待子进程,如返回ECHILD错误,证明该子进程是前台进程,已经被同步wait掉了,不需要后续处理;否则作为后台进程处理。
最后,我们发现同步等待的waitpid没有被中断的情况只在忽略信号的时候产生,而之前也证明了忽略信号时,系统压根不产生SIGCHLD信号,这两者似乎到现在是对上了…… :)
- 进程创建、exec函数簇,等待进程,替换进程实现
- Python 处理进程等待时间
- Linux下的C语言开发(进程等待)
- 进程线程协程那些事儿
- WaitForSingleObject 示例之一: 等待另一个进程的结束
- APUE 第八章 进程管理 子进程领养问题探讨
- linux下的C语言开发(进程等待)
- 进程的那些事儿
- [APUE] 再读之进程控制
- 父进程等待子进程的异步版本
- 进程等待与wait&waitpid
- linux下的C语言开发(进程等待)
- Linux C编程--进程介绍3--进程终止和等待
- 浅谈Linux进程等待
- 《unix高级环境编程》进程控制——进程等待
- python subprocess模块 监控子进程的2种方式 忙等待和立即返回同时设置子进程超时
- 父进程异步等待子进程
- apue 8-5调用fork两次以避免僵死进程
- 【APUE 学习笔记】4: Unix Process Control 进程控制
- 进程的等待wait() --多进程编程