前言
在操作系统中，进程等待是一种关键的机制，用于实现进程之间的同步和协作。通过等待子进程的结束并获取其退出状态，父进程可以控制程序的执行顺序和处理子进程的结果。本篇博客将介绍进程等待的原理和用法，帮助读者深入理解进程间通信的重要概念和技术。
进程等待必要性
- 之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。
- 另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。
- 最后，父进程派给子进程的任务完成的如何，我们需要知道。如果，子进程运行完成，结果对还是不对，或者是否正常退出。
- 父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息
模拟僵尸进程
在我们讲述进程状态的时候，我们讲述过僵尸进程指的是：子进程退出，父进程不管不顾
模拟代码：
#include <stdio.h> #include <unistd.h> #include <string.h> #include <stdlib.h> #include <sys/types.h> #include <sys/wait.h> int code = 0; int main() { pid_t id = fork(); if(id < 0) { perror("fork"); exit(1); //标识进程运行完毕，结果不正确 } else if(id == 0) { //子进程 int cnt = 5; while(cnt) { printf("cnt: %d, 我是子进程, pid: %d, ppid : %d\n", cnt, getpid(), getppid()); sleep(1); cnt--; } } else { //父进程 printf("我是父进程, pid: %d, ppid: %d\n", getpid(), getppid()); sleep(7); } }
运行结果：
查看状态的bash命令：
while :; do ps ajx | head -1 && ps ajx | grep mycode | grep -v grep; sleep 1; echo "-----------------------"; done
查看状态：
模拟成功！
进程等待的方法
子进程被创建出来，谁先运行，是有调度器说了算的。
那么谁先退出呢? 一般而言，我们通常要让子进程先退出。
为甚?
因为父进程可以很容易对子进程进行管理(垃圾回收)、处理业务，需要让父进程帮我们拿到子进程执行的结果。
一般子进程是需要被等待的，被父进程等，wait/waitpid.
wait方法
是什么?
是父进程通过wait等系统调用，用来等待子进程状态的一种现象，是必须的
为什么?
1.防止子进程发生僵尸问题，进而产生内存泄漏
2.读取子进程状态
怎么办?
wait/waitpid, status (signal， exit code).
#include<sys/types.h> #include<sys/wait.h> pid_t wait(int*status); 返回值： 成功返回被等待进程pid，失败返回-1。 参数： 输出型参数，获取子进程退出状态,不关心则可以设置成为NULL
参数:
输出型参数:将wait函数内部计算的结果通过status返回给调用者
输入型参数:调用者给被调用函数的传参
输入输出型参数编码的时候，小小的代码规范
输入型:给引用
输入输出，输出型参: 给指针
测试代码
#include <stdio.h> #include <sys/wait.h> #include <stdlib.h> #include <unistd.h> int main() { pid_t pid = fork(); if (pid < 0) { printf("fork error\n"); } else if (pid == 0) { int count = 0; while (1) { sleep(1); printf("i am child\n"); if (count == 3) { break; } count++; } exit(0); } else { int count = 0; while (1) { sleep(1); printf("i am father\n"); while (count == 5) { wait(NULL); } count++; } exit(0); } return 0; }
运行结果
waitpid方法
pid_ t waitpid(pid_ _t pid， int *status， int options) ;
pid :
Pid=-1,等待任一个子进程。与wait等效。
Pid>0，等待其进程ID与pid相等的子进程。.
status :同wait
options :
0 :阻塞模式
WNOHANG :非阻塞 模式
非阻塞模式需要搭配循环使用
pid_ t waitpid(pid_t pid, int *status, int options); 返回值： 当正常返回的时候waitpid返回收集到的子进程的进程ID； 如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0； 如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在； 参数： pid： Pid=-1,等待任一个子进程。与wait等效。 Pid>0.等待其进程ID与pid相等的子进程。 status: WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出） WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码） options: WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进 程的ID。
- 如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。
- 如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。
- 如果不存在该子进程，则立即出错返回。
测试代码
#include <stdio.h> #include <sys/wait.h> #include <unistd.h> #include <stdlib.h> int main() { pid_t pid = fork(); if (pid < 0) { printf("fork error!\n"); } else if (pid == 0) { //child int count = 0; while (count < 5) { printf("child is running, pid=%d\n", getpid()); sleep(1); count++; } exit(0); } else { //father printf("father wait before!\n"); pid_t ret = waitpid(pid, NULL, 0); if (ret > 0) { printf("wait success!\n"); } else { printf("wait failed\n"); } printf("father wait after!\n"); } return 0; }
运行结果
看下面结果图发现当父进程调用了waitpid函数时父进程就被阻塞了，阻塞期间当子进程运行完毕父进程才执行完毕，所以只有子进程退出了父进程才会退出，那么子进程就一定不是僵尸进程。
获取子进程status
pid_ t waitpid(pid_t pid, int *status， int options);
status:是一个整形指针，其实在传参的时候，该参数是一个输出型参数!
int st=0;
waitpid(pid, &st, 0); //开始等待，子进程退出，操作系统就会从进程PCB中读取退出信息，保存在status指向的变量中
返回之后，st中就保存的是我们进程退出的信息，int 是32bit，是否正常运行，退出码
是多少，退出信号是多少。
- wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。
- 如果传递NULL，表示不关心子进程的退出状态信息。
- 否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
- status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）：
- 次低8位表示子进程退出码
- 最低7个比特位表示进程收到的信号
//测试代码： #include <sys/wait.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> int main( void ) { pid_t pid; if ( (pid=fork()) == -1 ) perror("fork"),exit(1); if ( pid == 0 ){ sleep(20); exit(10); } else { int st; int ret = wait(&st); if ( ret > 0 && ( st & 0X7F ) == 0 ){ // 正常退出 printf("child exit code:%d\n", (st>>8)&0XFF); } else if( ret > 0 ) { // 异常退出 printf("sig code : %d\n", st&0X7F ); } } }
测试exit code,exit signal
#include <stdio.h> #include <unistd.h> #include <sys/wait.h> #include <stdlib.h> int main() { pid_t pid = fork(); if (pid < 0) { printf("fork error!\n"); } else if (pid == 0) { //child int count = 0; while (count < 5) { printf("child is running, pid=%d\n", getpid()); sleep(1); count++; } exit(0); } else { //father printf("father wait before\n"); int st = 0; pid_t ret = waitpid(pid, &st, 0); if (ret > 0) { printf("wait success!\n"); printf("st=%d\n", st); printf("child exit signal=%d\n", st & 0x7f); printf("child exit code=%d\n", (st >> 8) & 0xff); } if (st & 0x7F) { printf("child run error!\n"); } else { int code = (st >> 8) & 0xff; if (code) { printf("child run success, but result is not right: code=%d\n", code); } else { printf("child run success, and result is right: code=%d\n", code); } } } printf("wait after!\n"); return 0; }
1.父进程通过wait/waitpid可以拿到子进程的退出结果，为什么要用wait/waitpid函数呢?直接全局变量不行吗？
进程具有独立性，那么数据就要发生写时拷贝，父进程无法拿到，况且，信号呢? ?
2. 既然进程是具有独立性的，进程退出码，不也是子进程的数据吗? ?父进程又凭什么拿到呢? ?wait/waitpid究竟干了什么呢?
首先要知道僵尸进程至少要保留该进程的PCB信息！
task_struct里面保留了任何进程退出时的退出结果信息。
wait/waitpid 本质其实是读取子进程的task_struct结构 ，
task_struct 里面包含了： 【int exit_ code, exit_ signal;】
3.wait/waitpid有这个权利吗?
有，可以系统调用！ ，不就是操作系统吗! ! task_ struct 是内核数据结构对象! !
阻塞与非阻塞
- 阻塞等待是指一个任务在等待某个操作完成时，会被挂起，暂停执行直到操作完成后再继续执行。在阻塞等待期间，该任务无法进行其他的工作。
- 非阻塞等待是指一个任务在等待某个操作完成时，会使用轮询或回调的方式不断查询操作状态，可以继续执行其他任务。非阻塞等待不会让一个任务暂停执行，即使操作未完成。
- 两者的区别在于任务在等待某个操作完成时的行为表现：
- 阻塞等待会暂停任务的执行，直到操作完成。
- 非阻塞等待允许任务继续执行，并对操作状态进行查询或设置回调函数。
- 具体区别如下：
- 阻塞等待会造成任务阻塞，无法进行其他操作，而非阻塞等待允许任务继续执行其他操作。
- 阻塞等待的操作结果通常是通过阻塞等待的方式获取，而非阻塞等待需要主动轮询或回调来获取操作结果。
- 阻塞等待的效率较低，因为任务可能需要等待较长时间才能继续执行，而非阻塞等待可以提高任务的响应速度和并发性。
- 阻塞等待通常使用在同步模式下，保证任务的执行顺序；非阻塞等待则常用于异步模式下，充分利用系统资源。
进程的阻塞等待方式
#include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <sys/wait.h> int main() { pid_t pid; pid = fork(); if(pid < 0){ printf("%s fork error\n",__FUNCTION__); return 1; } else if( pid == 0 ){ //child printf("child is run, pid is : %d\n",getpid()); sleep(5); exit(257); } else{ int status = 0; pid_t ret = waitpid(-1, &status, 0);//阻塞式等待，等待5S printf("this is test for wait\n"); if( WIFEXITED(status) && ret == pid ){ printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status)); }else{ printf("wait child failed, return.\n"); return 1; } } return 0; }
进程的非阻塞等待方式
#include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <sys/wait.h> int main() { pid_t pid; pid = fork(); if(pid < 0){ printf("%s fork error\n",__FUNCTION__); return 1; }else if( pid == 0 ){ //child printf("child is run, pid is : %d\n",getpid()); sleep(5); exit(1); } else{ int status = 0; pid_t ret = 0; do { ret = waitpid(-1, &status, WNOHANG);//非阻塞式等待 if( ret == 0 ){ printf("child is running\n"); } sleep(1); }while(ret == 0); if( WIFEXITED(status) && ret == pid ){ printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status)); }else{ printf("wait child failed, return.\n"); return 1; } } return 0; }
后记
本篇讲述了进程等待的相关知识。
