进程等待和进程终止

进程终止
1》进程退出场景：

（a）程序运行完毕，结果正确
（b）程序运行完毕，结果不正确
（c）代码异常终止

2》进程退出方法：
（1）正常退出

(a)在main函数内执行return语句
(b)调用exit
(c)调用_exit或_Exit函数

(2)异常退出

(a) 调用abort。
(b)当进程接收到某些信号时。
(c) 最后一个线程对“取消”做出相应。

不管进程如何终止，最后都会执行进程内核中的同一段代码。这段代码为相应进程关闭所有打开描述符，释放它所使用的存储器等。

一般情况下，我们希望将终止进程的终止状态告知其父进程。对于以上exit,_exit,_Exit等函数，它将其退出状态作为参数传送给函数； 在异常终止情况，内核产生一个指示其异常终止原因的终止状态（在最后调用_exit时，内核将退出状态转换成终止状态。）

另一种情况，如果父进程在子进程之前终止，对于父进程已经终止的所有进程，它们的父进程都改变为init进程（孤儿状态之前已详述）；如果子进程在父进程之前终止，内核为每个终止子进程保存了一定量的信息，所以当终止进程的父进程调用wait或waitpid时，可以得到这些信息。这些信息至少包含进程ID，该进程终止状态以及该进程使用的CPU时间总量。
3》退出函数
(1)_exit
_exit是linux系统调用，关闭所有文件描述符，然后退出进程。

#include<unistd.h>
void _exit(int status);

参数status定义了进程的终止状态，父进程通过wait来获取该值。

（2）exit
exit是C语言的库函数，他最终也调用_exit。

#include<unistd.h>
void exit(int status);

工作流程
1.执行用户通过alexit或on_exit定义的清理函数。
2.关闭所有打开的流，所有的缓存数据均被写入。
3.调用_exit

对比演示

[a@localhost ~]$ vim exit.c
[a@localhost ~]$ cat exit.c
#include<stdio.h>
int main()
{
    printf("hello");
    exit(0);
}
[a@localhost ~]$ ./a.out
hello[a@localhost ~]$ 

[a@localhost ~]$ vim _exit.c
[a@localhost ~]$ cat _exit.c
#include<stdio.h>
int main()
{
    printf("hello");
    _exit(0);
}

[a@localhost ~]$ ./a.out
[a@localhost ~]$ 

（3）return
return退出是一种更常见的进程退出方法，等同于执行exit（n），因为调用main的运行时函数会将main的返回值当做exit的参数。

进程等待
目的：父进程通过进程等待的方式，回收子进程资源，获取子进程的退出信息，避免子进程进入僵尸状态。
调用wait或waitpid的进程可能会发生的情况：

（1）如果其所有进程都在运行，则阻塞。
（2）如果一个子进程已终止，正等待其父进程获取其终止状态，则取得该子进程的终止状态立即返回。
（3）如果没有任何子进程，则立即出错返回。

wait和waitpid函数

pid_t wait(int* status);

返回值：成功返回被等待进程pid，失败返回-1.
参数：status是一个整形指针，若不为空则终止进程的终止状态就存放在它所指向的单元，不关心则可以设置为NULL

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

返回值：正常返回的时候waitpid返回收集到的子进程的进程ID；调用中出错返回-1.
参数：

（1）pid pid=-1：等待任一个子进程，与wait等效。 pid>0:等待其进程ID与pid相等的子进程
（2）status WIFEXITED(status)：查看进程是否是正常退出 WEXITSTATUS(status)：查看进程的退出码
（3）options WNOHANG:若pid指定的子进程没有结束，则waitpid（）函数返回0，不予以等待。若正常结束，则返回该子进程的ID.

waitpid函数相比wait函数的优势：
（1）waitpid可等待一个特定的进程，而wait则返回任一终止子进程的状态。
（2）waitpid提供了wait的非阻塞版本。
（3）waitpid通过WUNTRACED 和WCONTINUED选项支持作业控制。

进程的阻塞等待方式：

#include<unistd.h>
#include<stdio.h>
#include<sys/wait.h>
int main()
{
    pid_t pid;
    pid = fork();
    if(pid < 0)
    {
      printf("%s fork error\n");
    }
    else if(pid == 0)
    {
      printf("child is run,pid is:%d\n",getpid());
      sleep(5);
      exit(1);
    }
    else
    {
      int status = 0;
      pid_t ret = waitpid(-1,&status,0);//阻塞式等待，等待5秒
      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;
}
[a@localhost ~]$ ./a.out
child is run,pid is:4930
this is test for wait
wait child 5s success,child return code is:1.
[a@localhost ~]$ 

进程的非阻塞等待方式：

[a@localhost ~]$ cat test.c
#include<unistd.h>  
#include<stdlib.h>  
#include<sys/wait.h>  
int main()  
{  
    pid_t pid=fork();  
    if(pid<0){  
        printf("fork is error\n");  
        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;  
}  
[a@localhost ~]$ ./a.out
child is running
child is run,pid is:4988
child is running
child is running
child is running
child is running
wait child 5s success,child return code is:1
[a@localhost ~]$ 

system/popen
1》system在其实现中调用了fork，exec和waitpid因此有三种返回值。
（1）fork失败或者waitpid返回除EINTR之外的出错，则system返回-1，并设置errno以指示错误类型。
（2）如果exec失败，则其返回值如同shell执行了exit（127）一样。
（3）否则所有3个函数都成功，那么system的返回值是shell的终止状态。
源码：

#include<stdio.h>
#include<unistd.h>
#include<errno.h>
#include<sys/wait.h>
int system(const char * cmdstring)
{
    pid_t pid;
    int status;
    if(cmdstring == NULL){         
         return (1);
    }

    if((pid = fork())<0){
            status = -1;//fork失败，返回-1
    }
    else if(pid = 0){
        execl("/bin/sh", "sh", "-c", cmdstring, (char *)0);
        _exit(127); //execl执行失败返回127
        }
    else{
            while(waitpid(pid, &status, 0) < 0){
                if(errno != EINTR){
                    status = -1;
                    break;
                }
            }
        }
        return status;
}

system的原理： 当system接受的命令为NULL时直接返回，否则fork出一个子进程，因为fork在两个进程：父进程和子进程中都返回，这里要检查返回的pid，fork在子进程中返回0，在父进程中返回子进程的pid，父进程使用waitpid等待子进程结束，子进程则是调用execl来启动一个程序代替自己，execl(“/bin/sh”, “sh”, “-c”, cmdstring, (char*)0)是调用shell，这个shell的路径是/bin/sh，后面的字符串都是参数，然后子进程就变成了一个shell进程，这个shell的参数是cmdstring，就是system接受的参数。
对比fork原理：当一个进程A调用fork时，系统内核创建一个新的进程B，并将A的内存映像复制到B的进程空间中，因为A和B是一样的，那么他们怎么知道自己是父进程还是子进程呢，看fork的返回值就知道，上面也说了fork在子进程中返回0，在父进程中返回子进程的pid。
popen

FILE *popen(const char *command, const char *type);
int pclose(FILE *stream);

2》popen() 函数用创建管道的方式启动一个 进程, 并调用 shell. 因为管道是被定义成单向的, 所以 type 参数只能定义成只读或者只写, 不能是两者同时, 结果流也相应的是只读或者只写. command 参数是一个字符串指针, 指向的是一个以 null 结束符结尾的字符串, 这个字符串包含一个 shell 命令. 这个命令被送到 /bin/sh 以 -c 参数执行, 即由 shell 来执行. type 参数也是一个指向以 null 结束符结尾的字符串的指针, 这个字符串必须是 ‘r’ 或者 ‘w’ 来指明是读还是写.

#include
int main(int argc, char *argv[])
{
         char buf[128];
         FILE *pp;

         if( (pp = popen("ls -l", "r")) == NULL )
         {
                 printf("popen() error!/n");
                 exit(1);
         }

         while(fgets(buf, sizeof buf, pp))
         {
                 printf("%s", buf);
         }
         pclose(pp);
         return 0;
}