Linux系统应用编程 --- 进程原语(三)

wait & waitpdi

1. 僵尸进程和孤儿进程的概念

僵尸进程

(1)子进程先于父进程结束。子进程结束后父进程此时并不一定立即就能帮子进程“收尸”,在这一段(子进程已经结束且父进程尚未帮其收尸)子进程就被称为僵尸进程。

(2)子进程除 task_struct 和栈外其余内存空间皆已清理

(3)父进程可以使用 wait 或 waitpid 以显式回收子进程的剩余待回收内存资源并且获取子进程退出状态。【父进程帮子进程收尸是要调用函数的】

(4)父进程也可以不使用 wait 或者 waitpid 回收子进程,此时父进程结束时一样会回收子进程的剩余待回收内存资源。(这样设计是为了防止父进程忘记显式调用 wait/waitpid 来回收子进程从而造成内存泄漏)

 

孤儿进程

(1)父进程先于子进程结束,子进程成为一个孤儿进程。

(2)linux 系统规定:所有的孤儿进程都自动成为一个特殊进程(进程 1,也就是 init 进程)的子进程。


2. wai & waitpid函数原型

wait是早起从unix继承过来的函数,是一个阻塞函数,比喻父进程调用wait之后,就会阻塞等待回收子进程,如果没有子进程结束,就一直阻塞,显然降低系统性能。

为了补救,后面又有了waitpid函数。

#include <sys/types.h>
 
#include <sys/wait.h>
 
pid_t wait(int *status);
 
pid_t waitpid(pid_t pid, int *status, int options);

wait返回值:成功回收子进程,返回终止的子进程的pid,错误返回-1

waitpid函数参数解释:

1) 参数1 pid

参数值

含义

pid<-1

等待进程组号为pid绝对值的任何子进程。

pid=-1

等待任何子进程,此时的waitpid()函数就退化成了普通的wait()函数。

pid=0

等待进程组号与目前进程相同的任何子进程,也就是说任何和调用waitpid()函数的进程在同一个进程组的进程。

pid>0

等待进程号为pid的子进程。

2)int *status

这个参数将保存子进程的状态信息,有了这个信息父进程就可以了解子进程为什么会退出,是正常退出还是出了什么错误。如果status不是空指针,则状态信息将被写入寄存器指向的位置。当然,如果不关心子进程为什么推出的话,也可以传入空指针。

Linux提供了一些非常有用的宏来帮助解析这个状态信息,这些宏都定义在sys/wait.h头文件中。主要有以下几个:

说明

WIFEXITED(status)

如果子进程正常结束,它就返回真;否则返回假。

WEXITSTATUS(status)

如果WIFEXITED(status)为真,则可以用该宏取得子进程exit()返回的结束代码。

WIFSIGNALED(status)

如果子进程因为一个未捕获的信号而终止,它就返回真;否则返回假。

WTERMSIG(status)

如果WIFSIGNALED(status)为真,则可以用该宏获得导致子进程终止的信号代码。

WSTOPSIG(status)

如果当前子进程被暂停了,则返回真;否则返回假。

WIFSTOPPED(status)

如果WIFSTOPPED(status)为真,则可以使用该宏获得导致子进程暂停的信号代码。

3) int options

参数options提供了一些另外的选项来控制waitpid()函数的行为。如果不想使用这些选项,则可以把这个参数设为0。主要使用的有以下两个选项:

参数

说明

WNOHANG

如果pid指定的子进程没有结束,则waitpid()函数立即返回0,而不是阻塞在这个函数上等待;如果结束了,则返回该子进程的进程号。

WUNTRACED

如果子进程进入暂停状态,则马上返回。

这些参数可以用“|”运算符连接起来使用。

如果waitpid()函数执行成功,则返回子进程的进程号;如果有错误发生,则返回-1,并且将失败的原因存放在errno变量中。

失败的原因主要有:没有子进程(errno设置为ECHILD),调用被某个信号中断(errno设置为EINTR)或选项参数无效(errno设置为EINVAL)

如果像这样调用waitpid函数:waitpid(-1, status, 0),这此时waitpid()函数就完全退化成了wait()函数。

3. 从code理解wait & waitpid函数的作用

code 1 : 

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <wait.h>
 
int main(void)
{
       pid_t pid, pid_c;
       //调用一次返回2次,在父进程返回子进程的PID,在子进程中返回0
 
       int n = 10;
       pid = fork();
     
       if(pid > 0)
       {/*in parent*/
              while(1)
              {
                     printf("I am parent pid = %d\n", getpid());
                     pid_c = wait(NULL);            //wait是一个阻塞函数,等待回收子进程资源
 
                                                               //如果没有子进程,wait返回-1
                     printf("wait for child %d.\n", pid_c);
                     sleep(1);
              }
       }
 
       else if(pid == 0)
       {/*in child*/
              //printf("I am child %d\n", n++);
              printf("I am child pid = %d.\n", getpid());
              //printf("my parent pid = %d.\n", getppid());
              sleep(10);
       }
 
       else
       {
              perror("fork");
              exit(0);
       }
 
       return 0;
}

执行结果如下:

分析:

刚进来的时候打印一次父子进程的ID号,然后子进程slepp 10s,父进程执行wait等待回收子进程,阻塞在这里,直到子进程结束,此时返回子进程的Pid号。子进程结束之后,wait的返回值就是-1.

僵尸进程对内存的影响:子进程如果没有回收,子进程占了一个PCB,浪费内存,造成内存泄露。

wait函数特点:

1. wait是一个阻塞函数,等待回收子进程资源,如果没有子进程,则返回-1.

2. wait函数回收子进程的PCB,避免浪费内存。既然会浪费内存,那么操作系统在设计的时候,为什么不把所有的僵尸进程都直接销毁?

因为操作系统需要知道每个进程是怎么销毁的,怎么获取一个进程的退出码,通过wait传参。

 

code 2 :

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <wait.h>
 
 
int main(void)
{
 
       pid_t pid;
 
       int n = 3;
 
       while(n--)
       {
              pid = fork();
              if(pid == 0) break;
       }
 
       if(pid == 0)
       {
              //while(1)
              {
                     printf("I am child %d.\n", getpid());
                     sleep(3);
              }
       }
 
       else if(pid > 0)
       {
 
              pid_t pid_c;
              while(1){
 
                     //pid_c = wait(NULL);
                     printf("I am parent.\n");
                     pid_c = waitpid(0, NULL, WNOHANG);
 
                     if(pid_c == -1)     
                            continue;
                     else
                            printf("wait for child %d.\n", pid_c);
                     if(pid_c > 0){
                            n++;     
                     }
                     if(n == 2)
                            break;                  
                     sleep(1);
              }
       }
      
       return 0;
}

一个父进程fork了三个子进程,通过ps – ajx查看

可以看到三个子进程的pid号依次递增,,父进程与三个子进程同属于一个进程组。(父进程创建子进程之后,子进程跟父进程默认是一个组)

如何kill掉一个进程组,命令【kill -9 -14943】

注释掉while(1),执行之后可以看到,通过WNOHANG确实将waitpid设置成了非阻塞的。
 

 

相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页