首页 / C++ / 【C/C++】多进程：父进程监听子进程状态 wait()的使用

【C/C++】多进程：父进程监听子进程状态 wait()的使用

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了【C/C++】多进程：父进程监听子进程状态 wait()的使用，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6871字，纯文字阅读大概需要10分钟。

内容图文

文章结构：

wait能力介绍

　　在上一篇【C/C++】多进程：子进程的创建fork()中演示了子进程的创建。

　　创建子进程后，父进程具有监听子进程的运行状态的能力，用到的函数为：

        
            #include <sys/wait.h>

   pid_t wait(int *status);
   pid_t waitpid(pid_t pid, int *status, int options);

　　以上函数用于等待子进程子进程的状态变化回调并且获取状态变化信息。所能获取到的状态变化包括：子进程运行结束、子进程被信号量暂停、子进程被信号量恢复运行。

　　父进程执行了wait函数后，如果子进程已经发生了状态变化，则wait函数立即就会有返回结果；否则wait函数会一直阻塞直至子进程状态发生变化。

　　通常意义上，如果子进程已经发生了状态变化，但还未被父进程或其它系统回调执行wait，则把此时的子进程称为是可等待的(waitable)。

　　子进程运行结束后，父进行执行wait函数可以推动系统释放与子进程相关的资源；否则子进程将会被维持在僵尸进程的状态下一直存在。　　

wait()函数讲解

　　函数wait(int * status)是对waitpid()的封装，限定了只有在任一子进程运行结束时才会有返回，否则调用进程会一起处于阻塞状态暂停执行。wait(int * status)等同于如下代码：

        
            waitpid(-1, &status, 0);

waitpid()会阻塞调用进程直至任一子进程的运行状态发生变化。接下来对waitpid()的三个参数进行讲解：　　

pid < -1取该pid的绝对值，如果任意子进程的进程组ID等于该绝对值，则该组进程中任一子进程中的进程状态发生变化都会触发waitpid()的回调。

pid == -1监听范围扩大到任意子进程。

pid == 0监听限制为子进程的进程组ID与父进程相等。

pid > 0监听限制为指定子进程进程ID值。

status

　　值可以为NULL。当不为NULL时，用于存储触发状态变化的信息号值和exit(code)中的code值。

wait.h头文件定义了几个宏用于解析status的值，常见的有：

宏	含义
WIFEXITED(status) WEXITSTATUS(status)	当子进程调用`exit(code)`或`_exit(code)`或正常运行到`main()`函数结尾时正常结束运行，则返回`true`。当`WIFEXITED(status)`为`true`时，获取`exit(code)`或`_exit(code)`的`code`值。其中`code`只能为0或正数，不支持负数。
WIFSIGNALED(status) WTERMSIG(status)	当子进程被信号量杀死时则返回`true`。当`WIFSIGNALED(status)`为`true`时，获取该信号量的值。
WIFSTOPPED(status) WSTOPSIG(status)	当子进程被信号量暂停执行时则返回`true`。当`WIFSTOPPED(status)`为`true`时，获取该信号量的值。

options

　　值可以是以下常量的任意值或任意常量与0的OR计算值。

常量	含义
WNOHANG	调用`wait`时指定的`pid`仍未结束运行，则`wait`立即返回0。
WUNTRACED	当子进程被暂停时，则`wait`立即返回子进程的`pid`。
WCONTINUED	当被暂停的子进程又被信号量恢复后，则`wait`立即返回子进程的`pid`。 Linux 2.6.10及以后生效。在Mac 0S X 10.9.5上未生效。

wait()函数在正常执行时会返回被终止进程的pid值，当执行发生错误后会返回-1。
waitpid()函数在正常执行时会返回进程状态发生变化的进程pid值；如果函数options中包含了WNOHANG常量，则会在指定pid的子进程未退出且进程状态也未发生变化时直接返回0，如果子进程已经退出了，则返回子进程的pid；否则当执行发生错误后会返回-1。

示例代码及操作演示

　　由于涉及到两个进程，在终端命令行下的日志打印会出现混乱，所以通过重定向标准输入输出流将两个进程的日志分别输出到两个文件中去，父进程的日志输出到main.txt中去，子进程的日志输出到child.txt中去。涉及到重定向标准输入输出流，具体细节见【C/C++】文件创建、打开、读、写、复制、关闭、删除等操作汇总。

　　涉及到的ps、kill命令可以通过man ps及man kill去查找细节。

　　接下来的代码将演示fork()一个子进程后，会通过ps命令查询进程状态，及kill命令向子进程发送信号量改变进程状态；父进程通过wait监听子进程状态。

wait.c源码如下：

                            
                                #include <sys/wait.h>
                            
                            
                                #include <errno.h>
                            
                            
                                #include <stdlib.h>
                            
                            
                                #include <string.h>
                            
                            
                                #include <unistd.h>
                            
                            
                                #include <stdio.h>
                            
                            
                                #include <time.h>
                            
                            
                            
                            
                                #ifndef CHILD_COUNT
                            
                            
                                #define CHILD_COUNT 10000
                            
                            
                                #endif
                            
                            
                            
                            
                            
                            
                                static
                                void printTime() {
                                time_t calendar_time = time(NULL);
                            
                                struct tm * tm_local = localtime(&calendar_time);
                            
                                char str_f_t [50];
                                strftime(str_f_t, sizeof(str_f_t), "%G-%m-%d %H:%M:%S", tm_local);
                            
                                printf("%s ", str_f_t);
                            }
                            
                            
                            
                                int main/*09*/(int argc, char *argv[]) {
                                pid_t cpid, w;
                            
                                int status;
                                cpid = fork();
                            
                                if (cpid == -1) {
                                    perror("fork");
                            
                                exit(EXIT_FAILURE);
                                }
                            
                                if (cpid == 0) {
                            
                                /* Code executed by child */
                            
                                    FILE* fChild = freopen("/Users/sodino/workspace/xcode/Define/Define/child.txt", "w", stdout);
                                    printTime();
                            
                                printf("Child PID is %ld  argc=%d\n", (long) getpid(), argc);
                            
                                int count = 0;
                            
                                do{
                                        sleep(1);
                                        printTime();
                            
                                printf("sleep count=%d\n", count);
                                        fflush(fChild);
                            
                            
                                        count ++;
                            
                                if (count > CHILD_COUNT) {
                            
                                break;
                                        }
                                    }while (1);
                                    fflush(fChild);
                                    fclose(fChild);
                            
                            
                            
                                // code值将从父进程的WEXITSTATUS()宏定义中获知
                            
                            
                                //      _exit(123);
                            
                            
                                exit(123);
                                } else {
                                    FILE * fMain = freopen("/Users/sodino/workspace/xcode/Define/Define/main.txt", "w", stdout);
                            
                            
                            
                                // 如果子进程还在，则返回0；如果子进程已经运行结束，则返回子进程pid
                            
                                    w = waitpid(cpid, &status, WNOHANG);
                            
                                if (w == 0) {
                                        printTime();
                            
                                printf("Child PID=%d has not yet changed state\n", cpid);
                                    } else {
                                        printTime();
                            
                                printf("Child PID=%d has been terminated.\n", cpid);
                                    }
                            
                            
                            
                                int ifExited, ifSignaled, ifStopped, ifContinued;
                            
                                /* Code executed by parent */
                            
                            
                                do {
                            
                                // 在mac上·WCONTINUED·无效，从头文件来看，只适用于thread
                            
                                        w = waitpid(cpid, &status, WUNTRACED | WCONTINUED);
                            
                                //            w = waitpid(cpid, &status, WUNTRACED);
                            
                            
                                if (w == -1) {
                                            printTime();
                            
                                printf("Parent w=-1, error=%s \n", strerror(errno));
                            
                                exit(EXIT_FAILURE);
                                        } if (w == 0) {
                                            printTime();
                            
                                printf("w == 0 ignore. continue.\n");
                            
                                continue;
                                        }
                            
                            
                                        ifExited = WIFEXITED(status);
                                        ifSignaled = WIFSIGNALED(status);
                                        ifStopped = WIFSTOPPED(status);
                                        ifContinued = WIFCONTINUED(status);
                            
                            
                                        printTime();
                            
                                printf("pid=%ld w=%d exitCode=%d status=%d ifExited=%d ifSignaled=%d ifStopped=%d ifContinued=%d \n", (long)getpid(),
                            
                                //                   w, status, WEXITSTATUS(w), ifExited, ifSignaled, ifStopped, ifContinued);
                            
                                               w, status, _WSTATUS(w), ifExited, ifSignaled, ifStopped, ifContinued);
                            
                            
                                        printTime();
                            
                                if (ifExited) {
                            
                                printf("PID=%ld exited, status=%d\n", (long)w, WEXITSTATUS(status));
                                        } elseif (ifSignaled) {
                            
                                printf("PID=%ld killed by signal %d\n", (long)w, WTERMSIG(status));
                                        } elseif (ifStopped) {
                            
                                printf("PID=%ld stopped by signal %d\n", (long)w, WSTOPSIG(status));
                                        } elseif (ifContinued) {
                            
                                printf("PID=%ld continued\n", (long)w);
                                        }
                                        fflush(fMain);
                            
                                if (ifExited || ifSignaled) {
                                            printTime();
                            
                                printf("isExited=%d   isSingaled=%d\n", ifExited, ifSignaled);
                                            fflush(fMain);
                            
                                break;
                                        }
                                    } while (1);
                            
                            
                                    printTime();
                            
                                printf("Main PID %ld  exit.\n", (long)getpid());
                            
                            
                                    fclose(fMain);
                            
                                exit(EXIT_SUCCESS);
                                }
                            }

　　进入到wait.c的目录下，执行如下命令编译并运行：

           gcc wait.c // 生成可执行文件a.out
   ./a.out// 运行可执行文件

　　使用ps -j命令，查看进程可以看到fork()执行后，进程列表中有两个名为a.out的进程。如下图：
技术分享

　　可以看到PID=678的进程其父进程是PID=677。两个进程的进程组ID(PGID)都为677。

　　再看上图中的STAT列，两个进程都是S+，其中S表示进程处于sleeping状态，原因是父进程在wait，而子进程除了打印日志外大部分时间都是在执行sleep()；另一个+表示这两个进程都是在当前控制台的前台进程。

　　接使用kill -SIGSTOP 678命令向子进程发送暂停信号，再ps -j查询一下进程状态，发现子进程678已经从S+变为T+，即已经进入STOP状态了。

技术分享

　　而另一方面，查看child.txt，发现该文件已经不会继续生成日志了。查看main.txt文件，日志内容如下：

        
            2015-04-1622:53:15 Child PID=678 has not yet changed state
  2015-04-1623:11:48pid=677w=678exitCode=4479status=38ifExited=0ifSignaled=0ifStopped=1ifContinued=02015-04-1623:11:48PID=678 stopped by signal 17

　　第一句Child PID=678 has not yet changed state是父进程执行waitpid:WNOHANG的返回结果，表示当时子进程仍未退出，正在运行。第二句则输出了ifStopped=1表示waitpid:WUNTRACED已经监听到子进程被外部发送的信号量导致进程状态发生变化了。第三句PID=678 stopped by signal 17表示信号量值是17，通过以下命令可能验证SIGSTOP信号量值为17：

          sodino:Define sodino$ kill -l SIGSTOP
  17

　　接下来，要继续使用kill -SIGCONT 678命令来恢复子进程的运行，操作见下图：
技术分享

　　由上图可见子进程从暂停状态又恢复运行了。查看child.txt日志则发现日志又恢复输出了：

        
            ...
            ...
            2015-04-1623:11:46 sleep count=11102015-04-1623:11:47 sleep count=11112015-04-1623:23:20 sleep count=11122015-04-1623:23:21 sleep count=1113......

　　注意看时间，从23:11分到23:23分这个时间段内进程状态是停止的所以没有日志输出(这段时间在写博客给你们看呀..)。查看main.txt则没有发现waitpid有回调，个人认为这是在我的mac上C版本及运行环境问题吧。

　　最后再使用命令kill -SIGTERM 678后，可以发现ps命令已经查询不到刚才的a.out进程了。　　
技术分享

　　查看main.txt可以发现waitpid有了返回值其中ifSignaled=1表示子进程已经被信号量15所杀死。并最后退出了。

        
            2015-04-1623:31:00pid=677w=678exitCode=15status=38ifExited=0ifSignaled=1ifStopped=0ifContinued=02015-04-1623:31:00PID=678 killed by signal 152015-04-1623:31:00isExited=0isSingaled=12015-04-1623:31:00 Main PID 677  exit.

　　以上，就是本篇想说的，下一篇：多进程：僵尸进程

原文：http://blog.csdn.net/sodino/article/details/45146005

内容总结

以上是互联网集市为您收集整理的【C/C++】多进程：父进程监听子进程状态 wait()的使用全部内容，希望文章能够帮你解决【C/C++】多进程：父进程监听子进程状态 wait()的使用所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1332840.html

来源：【匿名】

首页 / C++ / 【C/C++】多进程：父进程监听子进程状态 wait()的使用

【C/C++】多进程：父进程监听子进程状态 wait()的使用

内容导读

内容图文

wait能力介绍

wait()函数讲解

示例代码及操作演示

内容总结

内容备注

内容手机端

【【C/C++】多进程：父进程监听子进程状态 wait()的使用】教程文章相关的互联网学习教程文章

php扩展中c++单例模式的全局对象实例被生成多个子进程销毁，为啥？该如何解决

C++ - 技术教程分类

C++ - 最新教程

C++ - 最热教程