Linux:进程终止和进程等待

深情汤姆

已于 2024-06-13 10:07:10 修改

阅读量832

点赞数 24

文章标签： linux 运维服务器

于 2024-06-12 22:21:32 首次发布

本文链接：https://blog.csdn.net/qq_73874574/article/details/139636804

版权

一.进程终止

进程退出场景

·代码运行完毕，结果正确
·代码运行完毕，结果不正确
·代码异常终止

进程常见退出方法
正常终止（可以通过 echo $? 查看进程退出码）：

1. 从main返回
2. 调用exit3. _exit

异常退出：

ctrl + c，信号终止

_exit函数

#include <unistd.h>
void _exit(int status);
参数：status 定义了进程的终止状态，父进程通过wait来获取该值

说明：虽然status是int，但是仅有低8位可以被父进程所用。所以_exit(-1)时，在终端执行$?发现返回值是255。

exit函数

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

exit最后也会调用_exit, 但在调用_exit之前，还做了其他工作：

1. 执行用户通过 atexit或on_exit定义的清理函数。

2. 关闭所有打开的流，所有的缓存数据均被写入
3. 调用_exit

实例：

int main()
{
    printf("hello"); 
    exit(0);
}

运行结果：

int main()
{
     printf("hello");
     _exit(0);
}

运行结果：

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

二.进程等待

进程等待必要性

·子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。
·另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。
·最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。
·父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

进程等待的方法

wait方法

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);
返回值：
成功返回被等待进程pid，失败返回-1。

参数：
输出型参数，获取子进程退出状态,不关心则可以设置成为NULL

waitpid方法

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，子进程存在且正常运行，则进程可能阻塞。 ·如果不存在该子进程，则立即出错返回。

获取子进程status

·wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。

·如果传递NULL，表示不关心子进程的退出状态信息。
·否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
·status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）：

测试代码：

 int main( void )
 10 {
 11  pid_t pid;
 12  if ( (pid=fork()) == -1 )
 13    perror("fork"),exit(1);
 14  if ( pid == 0 )
 15  {
 16    sleep(20);
 17    exit(10);
 18  }
 19  else
 20  {
 21    int st;
 22    int ret = wait(&st);
 23  if ( ret > 0 && ( st & 0X7F ) == 0 )
 24  {
 25    // 正常退出 
 26    printf("child exit code:%d\n", (st>>8)&0XFF);
 27  }
 28  else if( ret > 0 )
 29  {
 30    // 异常退出
 31  printf("sig code : %d\n", st&0X7F );
 32  }
 33  }
 34 }

结果：

[root@localhost linux]# ./a.out #等20秒退出 child exit code:10
[root@localhost linux]# ./a.out #在其他终端kill掉 sig code : 9

具体代码实现
进程的阻塞等待方式：

  8 int main()
  9 {
 10  pid_t pid;
 11  pid = fork();
 12  if(pid < 0){
 13  printf("%s fork error\n",__FUNCTION__);
 14  return 1;
 15  }
 16  else if( pid == 0 )
 17  {
 18    //child 
 19    printf("child is run, pid is : %d\n",getpid());
 20    sleep(5);
 21    exit(257);
 22  }
 23  else
 24  {
 25  int status = 0;
 26  pid_t ret = waitpid(-1, &status, 0);
 27  //阻塞式等待，等待5S 
 28  printf("this is test for wait\n");
 29  if( WIFEXITED(status) && ret == pid )
 30  {
 31    printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));
 32  }
 33  else
 34  {
 35    printf("wait child failed, return.\n"); return 1;
 36  }
 37  }
 38  return 0;
 39 }

进程的非阻塞等待方式：

int main()
  9 {
 10  pid_t pid;
 11 
 12  pid = fork();
 13  if(pid < 0){
 14  printf("%s fork error\n",__FUNCTION__);
 15  return 1;
 16  }
 17  else if( pid == 0 )
 18  {
 19    //child 
 20    printf("child is run, pid is : %d\n",getpid());
 21    sleep(5);
 22    exit(1);
 23  }
 24  else
 25  {
 26  int status = 0;
 27  pid_t ret = 0;
 28  do
 29  {
 30  ret = waitpid(-1, &status, WNOHANG);//非阻塞式等待 
 31  if( ret == 0 )
 32  {
 33  printf("child is running\n");
 34  }
 35  sleep(1);
 36  }while(ret == 0);
 37 
 38  if( WIFEXITED(status) && ret == pid )
 39  {
 40    printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));
 41  }
 42  else
 43  {
 44    printf("wait child failed, return.\n"); return 1;                                                     
 45  }
 46  }
 47  return 0;
 48 }