Unix/Linux编程：进程的终止

喜欢ヅ旅行 2022-12-23 13:27 183阅读 0赞

# 进程的终止 #

通常，进程有两种终止方式。

*  其一为异常终止，由对一信号的接收而引发，该信号的默认动作为终止当前进程，可能产生核心转储（core dump）。
 *  其二为正常终止

> 5种正常终止：
> 
>  *  从`main`返回
>  *  调用`exit`
>  *  调用`_exit`和`_Exit`
>  *  最后一个线程从其启动例程返回
>  *  从最后一个线程调用`pthread_exit`
> 
> 3种异常终止：
> 
>  *  调用`abort`
>  *  接到一个信号
>  *  最后一个线程对取消请求做出响应

## \_exit()和exit() ##

进程可使用\_exit()系统调用正常终止。

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

\_exit()的status参数定义了进程的终止状态，父进程可以调用wait()以获取该状态。

调用\_exit()的程序总会成功终止（即，\_exit()从不返回）。

> 虽然可将 0～255 之间的任意值赋给\_exit()的 status 参数，并传递给父进程，不过如取值大于 128 将在 shell 脚本中引发混乱。原因在于，当以信号（signal）终止一命令时，shell 会将变量$?置为 128 与信号值之和，以表征这一事实。如果这与进程调用\_exit()时所使用的相同 status 值混杂起来，将令 shell 无法区分。

程序一般不会直接调用\_exit()，而是调用库函数exit()，它会在调用\_exit()前执行各种动作：

*  调用退出处理程序（通过 atexit()和 on\_exit()注册的函数），其执行顺序与注册顺序相反
 *  刷新stdio流缓冲区
 *  使用由status提供的值执行\_exit()系统调用

#include <stdlib.h>
     void exit (int __status)

> 与专属于 UNIX 的\_exit()不同，exit()则属于标准 C 语言函数库，也就是说，所有的 C语言实现都支持 exit()

程序的另一种终止方法是从main()函数中返回。

*  执行`return n`等同于执行`exit(n)`。因为调用main()的运行时函数会将main()的返回值作为exit()的参数
 *  存在一种情况，从 main()函数中返回与调用 exit()并不相同。如果在退出的处理过程中所执行的任何步骤需要访问 main()函数的本地变量，那么从 main()函数中返回会导致未定义的行为。

执行未指定返回值的 return，或是无声无息地执行到 main()函数结尾，同样会导致 main()的调用者执行 exit()函数

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center]

--------------------

关于退出函数：

#include <stdlib.h>
     void exit (int __status)
     void _Exit (int __status)
    
    #include <unistd.h>
    void _exit (int __status)

*  `_Exit`和`_exit`立即进入内核
 *  `exit`总是先清理，然后返回内核

## 进程终止的细节 ##

无论进程是否正常终止，都会发生如下动作：

*  关闭所有打开文件描述符、目录流、信息目录描述符（参考手册页 catopen(3)和 catgets(3)），以及（字符集）转换描述符（见iconv\_open(3)手册页）
 *  作为文件描述符关闭的后果之一，将释放该进程所持有的任何文件锁
 *  分离(detach)任何已连接的System V共享内存段，而且对于各段的shm\_mattch计数器值将减一
 *  进程为每个System V信号量所设置的semadj值将会被加到信号量值中
 *  如果该进程是一个管理终端的管理进程，那么系统会向该终端前台进程组中的每个进程发送SIGHUP信号，接着终端会与会话脱离
 *  将关闭该进程打开的任何 POSIX 有名信号量，类似于调用sem\_close()。
 *  将关闭该进程打开的任何 POSIX 消息队列，类似于调用mq\_close()。
 *  作为进程退出的后果之一，如果某进程组成为孤儿，且该组中存在任何已停止进程（stopped processes），则组中所有进程都将收到 SIGHUP 信号，随之为 SIGCONT 信号。
 *  移除该进程通过 mlock()或 mlockall()所建立的任何内存锁
 *  取消该进程调用 mmap()所创建的任何内存映射（mapping）

## 退出处理程序 ##

退出处理程序是一个由程序设计者提供的函数，可于进程生命周期的任意时点注册，并在该进程调用 exit()正常终止时自动执行。如果程序直接调用\_exit()或因信号而异常终止，则不会调用退出处理程序。

>  *  当进程收到信号而终止时，将不会调用退出处理程序。这一事实一定程度上限制了它们的效用。
>  *  此时最佳的应对方式莫若为可能发送给进程的信号建立信号处理程序，并于其中设置标志位，令主程序据此来调用 exit()。因为 exit()不属于异步信号安全（asyncsignal-safe）函数，所以通常不能在信号处理程序中对其发起调用。
>  *  即便如此，还是无法处理SIGKILL 信号，因为无法改变 SIGKILL 的默认行为。这也是应该避免使用 SIGKILL 来终止进程的另一原因。建议使用信号 SIGTERM，这也是 kill 命令默认发送的信号

### 注册退出处理程序 ###

GNU C 语言函数库提供两种方式来注册退出处理程序。

第一种方法是使用由 SUSv3 定义的 atexit()函数

/*
    * 参数：函数地址
    * 作用： 一个进程最多可以通过atexit 登记32个函数（这些函数叫做终止处理程序），这些函数将由exit自动调用，exit调用的顺序与登陆顺序相反，如果同一个函数被多次等记，将会被多次调用
    * 返回值：成功0，失败非0
    */
    int atexit (void (*__func) (void))

函数atexit()将func加到一个函数列表中，进程终止时会调用该函数的所有函数，func()一般格式如下：

void func(void) {
        
    	...	
    }

可以注册多个退出处理程序（甚至可以将同一函数注册多次）。当应用程序调用 exit()时这些函数的执行顺序与注册顺序相反。

本质上，可以在退出处理程序中执行任何希望的动作，包括注册附加的退出处理程序，并将其置于留待调用函数列表的头部。不过，一旦有任一退出处理程序无法返回—无论因为调用了\_exit()还是进程因收到信号而终止（例如，退出处理程序调用函数 raise()），那么就不会再调用剩余的处理程序。此外，调用 exit()时通常需要执行的剩余动作也将不再执行。

> SUSv3 规定，若退出处理程序自身调用 exit()，其结果未定义。在Linux 上，会照常调用剩余的退出处理程序。不过，在某些系统上，这将导致对所有退出处理程序的再次调用，并引发无限循环调用（直至栈溢出将该进程杀死）。为保障可移植性，应用程序应避免在退出处理程序内部调用 exit()。

SUSv3 要求系统实现应允许一个进程能够注册至少 32 个退出处理程序。使用系统调用sysconf(\_SC\_ATEXIT\_MAX)，应用程序即可确定由实现所定义的可注册退出处理程序的数量上限。（但是，并无方法获知有多少已注册的处理程序。）通过运用动态分配链表将已注册的  
处理程序串接起来，glibc 允许注册的退出处理程序数量近乎于无限。对于 Linux，sysonf(\_SC\_ATEXIT\_MAX)返回 2147482647（即，32 位有符号整型数的最大值）。换言之，在触及可注册函数数量的这一上限前，总会有其他原因（例如，内存不足）导致程序崩溃

通过fork()创建的子进程会继承父进程注册的退出处理函数。而进程调用exec()时，会移除所有已注册的退出处理程序。（这是结果势所必然，因为 exec()会替换包括退出处理程序在内的所有原程序代码段。）

> 无法取消经由atexit()或者on\_exit()注册的退出处理程序。不过，可以令退出处理程序在执行动作之前检查全局执行标志是否置位，或者清楚该标志来屏蔽退出处理程序。

经由atexit()注册的退出处理程序会受到两种限制：

*  其一，退出处理程序在执行时无法获知传递给 exit()的状态。有时候，知道状态是必要的；例如，退出处理程序会视进程退出成功与否而执行不同的动作。
 *  其二，无法给退出处理程序指定参数。如果拥有这一特性，退出处理程序能根据传入参数的不同而执行不同动作，或使用不同参数多次注册同一个函数。

为摆脱这些限制，glibc 提供了一个（非标准的）替代方法： on\_exit()。

SYNOPSIS
           #include <stdlib.h>
    
           int on_exit(void (*function)(int , void *), void *arg);
    
    返回值：
    		成功0，失败非0

函数 on\_exit()的参数 func 是一个指针，指向如下类型的函数:

void func(int status, void * arg){
        
    }

调用时，会传递两个参数给 func()：提供给 exit()的 status 参数和注册时供给 on\_exit()的一份 arg 参数拷贝。虽然定义为指针类型，参数 arg 的意义仍然可由设计者支配。可将其用作指向结构的指针，同样，通过审慎地强制转换，也可将其作为整型或其他标量类型使用

如同 atexit()一样，通过 on\_exit()可以注册多个退出处理程序。使用 atexit()和 on\_exit()注册的函数位于同一函数列表。如果在程序中同时用到了这两种方式，则会按照使用这两个方法注册的相反顺序来执行相应的退出处理程序。

虽然比 atexit()更灵活，但对于要保障可移植性的程序来说，还是应避免使用 on\_exit()。因为并无标准涵盖到它，并且几乎也没有其他 UNIX 实现支持这一用法。

看个例子：

#include <stdlib.h>
    #include <stdio.h>
    static void	my_exit1(void);
    static void	my_exit2(void);
    
    int main(void)
    {
        
        if (atexit(my_exit2) != 0){
        
            perror("can't register my_exit2");
            exit(EXIT_FAILURE);
        }
    
    
        if (atexit(my_exit1) != 0){
        
            perror("can't register my_exit1");
            exit(EXIT_FAILURE);
        }
    
        if (atexit(my_exit1) != 0){
        
            perror("can't register my_exit1");
            exit(EXIT_FAILURE);
        }
    
    
        printf("main is done\n");
        return(0);
    }
    
    static void my_exit1(void)
    {
        
        printf("first exit handler\n");
    }
    
    static void my_exit2(void)
    {
        
        printf("second exit handler\n");
    }
    
    static void my_exit2(void)
    {
        
        printf("second exit handler\n");
    }

![在这里插入图片描述][20201125115109686.png_pic_center]

第二个例子：

#define _BSD_SOURCE     /* Get on_exit() declaration from <stdlib.h> */
    #include <stdlib.h>
    #include <stdio.h>
    
    #ifdef __linux__        /* Few UNIX implementations have on_exit() */
    #define HAVE_ON_EXIT
    #endif
    static void
    atexitFunc1(void)
    {
        
        printf("atexit function 1 called\n");
    }
    static void
    atexitFunc2(void)
    {
        
        printf("atexit function 2 called\n");
    }
    #ifdef HAVE_ON_EXIT
    static void
    onexitFunc(int exitStatus, void *arg)
    {
        
        printf("on_exit function called: status=%d, arg=%ld\n",
               exitStatus, (long) arg);
    }
    #endif
    int
    main(int argc, char *argv[])
    {
        
    #ifdef HAVE_ON_EXIT
        if (on_exit(onexitFunc, (void *) 10) != 0){
        
            perror("on_exit 1");
            exit(EXIT_FAILURE);
        }
    
    #endif
        if (atexit(atexitFunc1) != 0){
        
            perror("atexit 1");
            exit(EXIT_FAILURE);
        }
    
        if (atexit(atexitFunc2) != 0){
        
            perror("atexit 2");
            exit(EXIT_FAILURE);
        }
    #ifdef HAVE_ON_EXIT
        if (on_exit(onexitFunc, (void *) 20) != 0){
        
            perror("on_exit 2");
            exit(EXIT_FAILURE);
        }
    #endif
    
        exit(2);
    }

![在这里插入图片描述][20210529143513467.png]

## fork()、stdio 缓冲区以及\_exit()之间的交互 ##

我们先来看个例子：

#define _BSD_SOURCE     /* Get on_exit() declaration from <stdlib.h> */
    #include <stdlib.h>
    #include <stdio.h>
    #include <zconf.h>
    
    int
    main(int argc, char *argv[])
    {
        
        printf("Hello world\n");
        write(STDOUT_FILENO, "Ciao\n", 5);
    
        if (fork() == -1){
        
            perror("fork");
            exit(EXIT_FAILURE);
        }
    
    
        /* Both child and parent continue execution here */
    
        exit(EXIT_SUCCESS);
    }

当程序标准输出定向到终端时，会看到：  
![在这里插入图片描述][20210529143747825.png]  
不过，当重定向标准输出到一个文件时，结果如下：  
![在这里插入图片描述][20210529143800944.png]  
以上输出中有两件怪事：printf()的输出行出现了两次，且 write()的输出先于 printf()。

要理解printf()的输出信息为什么出现了两次：

*  首先要记住，是在进程的用户空间内存中维护stdio缓冲区的。
 *  因此，通过fork()创建子进程时会复制这些缓冲区。
    
     *  当标准输出定向到终端时，因为缺省为行缓冲，所以会立即显示函数 printf()输出的包含换行符的字符串。
     *  不过，当标准输出重定向到文件时，由于缺省为块缓冲，所以当调用 fork()时，printf()输出的字符串仍在父进程的 stdio 缓冲区中，并随子进程的创建而产生一份副本。父、子进程调用 exit()时会刷新各自的 stdio 缓冲区，从而导致重复的输出结果

可以采用以下任一方法来避免重复的输出结果

*  作为针对 stdio 缓冲区问题的特定解决方案，可以在调用 fork()之前使用函数 fflush()来刷新 stdio 缓冲区。作为另一种选择，也可以使用 setvbuf()和 setbuf()来关闭 stdio 流的缓冲功能。
 *  子进程可以调用\_exit()而非 exit()，以便不再刷新 stdio 缓冲区。这一技术例证了一个更为通用的原则：**在创建子进程的应用中，典型情况下仅有一个进程（一般为父进程）应通过调用 exit()终止，而其他进程应调用\_exit()终止，从而确保只有一个进程调用退出处理程序并刷新 stdio 缓冲区**，这也算是众望所归吧

至于write()的输出并未出现两次，是因为write()会将数据直接传给内核缓冲区，fork()不会复制这一缓冲区。

write()的输出结果先于printf()出现，是因为write()会将数据立即传给内核高速缓存，而printf()的输出需要等到调用exit()刷新缓冲区

# 总结 #

进程的终止分为正常和异常两种。异常终止通常是由于某些信号引起的，其中的一些信号还可能导致进程产生一个核心转储文件

正常的终止可以通过过调用\_exit()完成，更多的情况下，则是使用\_exit()的上层函数 exit()完成。\_exit()和 exit()都需要一个整型参数，其低 8 位定义了进程的终止状态。依照惯例，状态 0用来表示进程成功完成，非 0 则表示异常退出

不管进程正常终止与否，内核都会执行多个清理步骤。调用exit()正常终止一个进程，将会引发执行经由 atexit()和 on\_exit()注册的退出处理程序（执行顺序与注册顺序相反），同时刷新 stdio 缓冲区

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/529bb513d7e947efa7e3578ffeea2eeb.png
[20201125115109686.png_pic_center]: /images/20221120/565c376391f94cd5a43c924f09b3aa39.png
[20210529143513467.png]: https://img-blog.csdnimg.cn/20210529143513467.png
[20210529143747825.png]: https://img-blog.csdnimg.cn/20210529143747825.png
[20210529143800944.png]: https://img-blog.csdnimg.cn/20210529143800944.png