零基础Linux_10(进程)进程终止(main函数的返回值)+进程等待

1. 进程终止

1.1 main函数的返回值

1.2 进程退出码和错误码

1.3 进程终止的常见方法

2. 进程等待

2.1 进程等待的原因

2.2 wait 函数

2.3 waitpid 函数

2.4 int* status参数

2.5 int options非阻塞等待

本篇完。

1. 进程终止

进程终止指的就是程序执行结束了，进程终止退出的场景有三种：

代码运行完毕且结果正确
代码运行完毕但结果不正确
代码异常终止

1.1 main函数的返回值

刚开始是如何学习 C/C++ 的呢？

#include <stdio.h>
 
int main()
{
    printf("hello world!\n");
    
    return 0;
}

C/C++ 的时侯，main函数就是所谓的 入口函数。

大家对 hello world! 再熟悉不过了，但是不知道大家是否关注过这个 return ?

下面我们思考两个问题：

① 这个return 0究竟给谁return?

② 为什么是0？其它值不行吗？

上面提到：进程终止退出的场景有三种：

代码运行完毕且结果正确
代码运行完毕但结果不正确
代码异常终止

返回值为 0，表示进程代码跑完。结果是否正确？-> 我们用 0 表示正确，非 0 表示不正确。（因为正确的原因只有一种，不正确的原因确有很多种）

所以，写main函数无脑返回 0 是不正确的，准确来说应该要给不同的值。

1.2 进程退出码和错误码

0 表示正确，非 0 表示不正确。那么这么多非0，我们要返回那个值？

我们把 main 函数的返回值称之为 进程退出码。

进程退出码是非常重要的，进程退出码表征了进程推出的信息，它是要给父进程读取的。

我们通过内置命令echo，我们让bash自己执行内部的函数来打印：（这里创建linux_10目录）

编译运行后输入几次echo $?

这里之所以会第一次执行echo $?得到 7，后面再输入得到 0，原因如下：

$? 表示在 bash 中，最近一次执行完毕时，对应进程的退出码，这里第一次我们运行test，退出码是7，echo $?，也是一个进程，这里它的退出码是0

所以我们来试试使用 ls 指令后输入 echo $?

这里 ls 中打开一个没有的文件，退出码是2？为什么这么设计呢？

我们先看看错误码：

首先，失败的非零值是可以自定义的，我们可以看看系统对于不同数字默认的错误码是什么含义。C 语言当中有个的 string.h 中有一个 strerror 接口，是最经典的、将错误码表述打印出来的接口，我们可以在写个代码去把这些错误码给打印出来：（这里有133个，往后面打都是不知道的错误了）

0是成功， 1表示权限不允许，2表示找不到文件或目录......输出错误原因定义归纳整理如下：（这里先不用记，记也记不下来，可以看看前十个）

#define EPERM 1 /* Operation not permitted */
#define ENOENT 2 /* No such file or directory */
#define ESRCH 3 /* No such process */
#define EINTR 4 /* Interrupted system call */
#define EIO 5 /* I/O error */
#define ENXIO 6 /* No such device or address */
#define E2BIG 7 /* Argument list too long */
#define ENOEXEC 8 /* Exec format error */
#define EBADF 9 /* Bad file number */
#define ECHILD 10 /* No child processes */
#define EAGAIN 11 /* Try again */
#define ENOMEM 12 /* Out of memory */
#define EACCES 13 /* Permission denied */
#define EFAULT 14 /* Bad address */
#define ENOTBLK 15 /* Block device required */
#define EBUSY 16 /* Device or resource busy */
#define EEXIST 17 /* File exists */
#define EXDEV 18 /* Cross-device link */
#define ENODEV 19 /* No such device */
#define ENOTDIR 20 /* Not a directory */
#define EISDIR 21 /* Is a directory */
#define EINVAL 22 /* Invalid argument */
#define ENFILE 23 /* File table overflow */
#define EMFILE 24 /* Too many open files */
#define ENOTTY 25 /* Not a typewriter */
#define ETXTBSY 26 /* Text file busy */
#define EFBIG 27 /* File too large */
#define ENOSPC 28 /* No space left on device */
#define ESPIPE 29 /* Illegal seek */
#define EROFS 30 /* Read-only file system */
#define EMLINK 31 /* Too many links */
#define EPIPE 32 /* Broken pipe */
#define EDOM 33 /* Math argument out of domain of func */
#define ERANGE 34 /* Math result not representable */
#define EDEADLK 35 /* Resource deadlock would occur */
#define ENAMETOOLONG 36 /* File name too long */
#define ENOLCK 37 /* No record locks available */
#define ENOSYS 38 /* Function not implemented */
#define ENOTEMPTY 39 /* Directory not empty */
#define ELOOP 40 /* Too many symbolic links encountered */
#define EWOULDBLOCK EAGAIN /* Operation would block */
#define ENOMSG 42 /* No message of desired type */
#define EIDRM 43 /* Identifier removed */
#define ECHRNG 44 /* Channel number out of range */
#define EL2NSYNC 45 /* Level 2 not synchronized */
#define EL3HLT 46 /* Level 3 halted */
#define EL3RST 47 /* Level 3 reset */
#define ELNRNG 48 /* Link number out of range */
#define EUNATCH 49 /* Protocol driver not attached */
#define ENOCSI 50 /* No CSI structure available */
#define EL2HLT 51 /* Level 2 halted */
#define EBADE 52 /* Invalid exchange */
#define EBADR 53 /* Invalid request descriptor */
#define EXFULL 54 /* Exchange full */
#define ENOANO 55 /* No anode */
#define EBADRQC 56 /* Invalid request code */
#define EBADSLT 57 /* Invalid slot */
#define EDEADLOCK EDEADLK
#define EBFONT 59 /* Bad font file format */
#define ENOSTR 60 /* Device not a stream */
#define ENODATA 61 /* No data available */
#define ETIME 62 /* Timer expired */
#define ENOSR 63 /* Out of streams resources */
#define ENONET 64 /* Machine is not on the network */
#define ENOPKG 65 /* Package not installed */
#define EREMOTE 66 /* Object is remote */
#define ENOLINK 67 /* Link has been severed */
#define EADV 68 /* Advertise error */
#define ESRMNT 69 /* Srmount error */
#define ECOMM 70 /* Communication error on send */
#define EPROTO 71 /* Protocol error */
#define EMULTIHOP 72 /* Multihop attempted */
#define EDOTDOT 73 /* RFS specific error */
#define EBADMSG 74 /* Not a data message */
#define EOVERFLOW 75 /* Value too large for defined data type */
#define ENOTUNIQ 76 /* Name not unique on network */
#define EBADFD 77 /* File descriptor in bad state */
#define EREMCHG 78 /* Remote address changed */
#define ELIBACC 79 /* Can not access a needed shared library */
#define ELIBBAD 80 /* Accessing a corrupted shared library */
#define ELIBSCN 81 /* .lib section in a.out corrupted */
#define ELIBMAX 82 /* Attempting to link in too many shared libraries */
#define ELIBEXEC 83 /* Cannot exec a shared library directly */
#define EILSEQ 84 /* Illegal byte sequence */
#define ERESTART 85 /* Interrupted system call should be restarted */
#define ESTRPIPE 86 /* Streams pipe error */
#define EUSERS 87 /* Too many users */
#define ENOTSOCK 88 /* Socket operation on non-socket */
#define EDESTADDRREQ 89 /* Destination address required */
#define EMSGSIZE 90 /* Message too long */
#define EPROTOTYPE 91 /* Protocol wrong type for socket */
#define ENOPROTOOPT 92 /* Protocol not available */
#define EPROTONOSUPPORT 93 /* Protocol not supported */
#define ESOCKTNOSUPPORT 94 /* Socket type not supported */
#define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */
#define EPFNOSUPPORT 96 /* Protocol family not supported */
#define EAFNOSUPPORT 97 /* Address family not supported by protocol */
#define EADDRINUSE 98 /* Address already in use */
#define EADDRNOTAVAIL 99 /* Cannot assign requested address */
#define ENETDOWN 100 /* Network is down */
#define ENETUNREACH 101 /* Network is unreachable */
#define ENETRESET 102 /* Network dropped connection because of reset */
#define ECONNABORTED 103 /* Software caused connection abort */
#define ECONNRESET 104 /* Connection reset by peer */
#define ENOBUFS 105 /* No buffer space available */
#define EISCONN 106 /* Transport endpoint is already connected */
#define ENOTCONN 107 /* Transport endpoint is not connected */
#define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */
#define ETOOMANYREFS 109 /* Too many references: cannot splice */
#define ETIMEDOUT 110 /* Connection timed out */
#define ECONNREFUSED 111 /* Connection refused */
#define EHOSTDOWN 112 /* Host is down */
#define EHOSTUNREACH 113 /* No route to host */
#define EALREADY 114 /* Operation already in progress */
#define EINPROGRESS 115 /* Operation now in progress */
#define ESTALE 116 /* Stale NFS file handle */
#define EUCLEAN 117 /* Structure needs cleaning */
#define ENOTNAM 118 /* Not a XENIX named type file */
#define ENAVAIL 119 /* No XENIX semaphores available */
#define EISNAM 120 /* Is a named type file */
#define EREMOTEIO 121 /* Remote I/O error */
#define EDQUOT 122 /* Quota exceeded */
#define ENOMEDIUM 123 /* Nomedium found */
#define EMEDIUMTYEP 124 /*Wrongmedium found */
#define ECANCELED 125 /* Operation Canceled */
#define ENOKEY 126 /* Required key not available */
#define EKEYEXPIRED 127 /* Key has expired */
#define EKEYREVOKED 128 /* Key has been revoked */
#define EKEYREJECTED 129 /* Key was rejected by service */
#define EOWNERDEAD 130 /* Owner died */
#define ENOTRECOVERABLE 131 /* State not recoverable */
#define ERFKILL 132 /* Operation not possible due to RF-kill */
#define EHWPOISON 133 /* Memory page has hardware error */

错误码退出码可以对应不同的错误原因，方便我们定位问题出在哪里。

1.3 进程终止的常见方法

进程终止的常见方法：① 在main函数return ② 调用 exit ③ 调用 _exit

两个QA：

1. 在main函数return（为什么其他函数不行）？：

只有在 main 函数调 return 才叫做进程退出，其他函数调 return 叫做函数返回。

2. 为什么在的代码任意地点中，调用 exit 都可以做到进程退出。

exit：该函数想必大家并不陌生，exit 并不是一个系统调用，而是用C语言写的，头文件是stdlib.h

我们来用一下这个 exit 函数：

编译运行：

在 main 函数调了 func 函数，进去打印后执行了 exit，最后进程没有返回直接在函数内部直接终止进程，这就叫调 exit 直接终止进程。此时我们 echo $? 得到的结果是 7。

exit 当然也是可以在 main 函数中使用的，这里就不演示了。如果你以后想终止一个进程，只需要在任意地点调用 exit 去 "代表" 进程退出。

下面我们再来讲解一下 _exit 函数，_exit 也是一个系统调用，也是可以用来终止进程的。

exit 和 _exit 是调用和被调用的关系，exit 是调用了 _exit 的。

区别：_exit()是系统调用，而exit()是库函数。exit 会清理缓冲区，关闭流等操作，而 _exit 什么都不干，直接终止：

结合以前缓冲区的知识，这里没了\n，用_exit ：

换成exit：

据此，我们以后直接用exit就行了。

2. 进程等待

进程等待是进程的一种状态，是父进程等待子进程退出时的一个过程。

2.1 进程等待的原因

子进程退出，父进程不管子进程，子进程就要处于僵尸状态，从而导致内存泄漏。

所以我们必须让其从 Z 状态变为 X 状态，进而允许操作系统能去释放它。

上面我们讲的实际上就是我们需要进程等待的一个原因 —— 解决内存泄露问题 。

然而不仅仅这一个原因，我们还需要进程等待来 获取子进程的退出状态 。

获取子进程的退出状态是否需要将曾经子进程的退出信息保存起来，然后被恢复、读取呢？

这和我们刚才讲的进程退出有着很大的关系，我们知道了进程退出是有退出码的。

我们需要让子进程退出时它的 return 结果或者 exit 的结果是需要被父进程读到的。

父进程创建了子进程，是要让子进程办事的，那么子进程把任务完成的怎么样了父进程需要关心吗？如果需要，如何得知？如果不需要，该怎么处理？

父进程通过进程等待的方式，回收子进程资源，获得子进程退出信息。

需要进程等待的原因：① 解决内存泄露问题 ② 获取子进程的退出状态

进程终止退出的场景有三种：（进程等待就是依照下面三种问题进程处理）

代码运行完毕且结果正确
代码运行完毕但结果不正确
代码异常终止

2.2 wait 函数

我们先来介绍一下 wait 函数。第一种方式，就是让父进程调用 wait 即可。

wait() 可以解决回收子进程 Z 状态，让子进程进入 X 状态。

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

返回值：成功返回被等待子进程pid，失败返回 - 1。
参数int* status：输出型参数，获取子进程退出状态, 不关心则可以设置成为NULL

验证：调用 wait 函数让父进程等待子进程：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
    pid_t id = fork();
    if (id == 0)
    {
        int cnt = 5;
        while (cnt--) 
        {
            printf("我是子进程%d，我在运行，Pid: %d\n", cnt,getpid());
            sleep(1);
        }
        exit(0); // 退出子进程
    }
    else
    {
        printf("我是父进程: 我在等待子进程，pid: %d，\n", getpid());
        sleep(7);
        pid_t ret = wait(NULL);  // 阻塞式等待，暂且将status参数设置为NULL
        if (ret < 0)
        {
            printf("等待失败！\n");
        }
        else 
        {
            printf("等待成功！\n");   // 此时 Z → X
        }
        while (1) // 阻塞式等待不会走到这
        {
            printf("我是父进程，我在运行，Pid: %d\n", getpid());
            sleep(1);
        }
    }
    return 0;
}

为了观察进程状态，在右边开一会话，写一段监控脚本（注意这里grep test是我生成的可执行文件名字test），做到每隔一秒就监控一下进程，右边输入：

while :; do ps ajx | head -1 && ps ajx | grep test| grep -v grep; echo "-------------------------------------------"; sleep 1; done

左边编译运行：

右边看到了两秒的僵尸进程Z：

成功验证了父进程等待了子进程。

通过 wait() 的方案，我们可以解决回收子进程的 Z 状态，让子进程进入 X 状态。

2.3 waitpid 函数

刚才讲的 wait 其功能比较简单，在进程等待时用的更多的是 waitpid

waitpid 可以把 wait 完全包含，wait 是 waitpid 的一个子功能。

wait/waitpid 都可以回收子进程的僵尸状态。

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

返回值：

如果 pid_t > 0：等待子进程成功，返回值就是子进程的 pid；
如果 pid_t < 0：等待失败。

在非阻塞等待中，没有等待失败，如果 pid_t = 0：如果子进程没有终止，那么返回0，如果终止且等待成功，返回子进程的pid值。

参数 pid_t pid：

设置参数 pid > 0：是几，就代表等待哪一个子进程，比如 pid=1234，指定等待。
设置参数 pid = -1：等待任意进程。（wait的就是等待任意进程）

参数int* status：和wait一样，输出型参数，获取子进程退出状态, 不关心则可以设置成为NULL（后面详讲）

对于参数 int options：0为阻塞等待（wait的就是阻塞等待），1为非阻塞等待，

非阻塞等待一般传WNOHANG（这个宏定义就直接定义为了1，Wait NO HANG夯住了（停了））。

在使用wait的代码的基础上，参数这样改就和wait一样了：

编译运行+监控：

while :; do ps ajx | head -1 && ps ajx | grep test| grep -v grep; echo "-------------------------------------------"; sleep 1; done

2.4 **int* status参数**

wait 和 waitpid，都有这个 status 参数，我们刚才演示 wait 的时候传的是 NULL，

如果传递 NULL，则表示不关心子进程的退出状态信息。否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。

该参数是一个输出型参数（即通过调用该函数，从函数内部拿出来特定的数据）。

并且，status 参数是由操作系统填充的，是一个整数，该整数就是下面我们要详细研究的。

它虽然是一个 int 型整数，但不能简单的当作整形来看待，

可以当作位图来看待，具体细节如下图（只研究status低16比特位）：

core dump 指的是 核心转储，也可以称之为 "吐核"。

它是操作系统在进程收到某些信号而终止运行时，将此时进程地址空间的内容以及有关进程状态的其他信息写出的一个磁盘文件。目前只需要知道，该信息是用于调试的。

现在上面的代码改一点，使用 waitpid 的 int* status参数，

验证： 通过提取 status 的次低8位，拿到子进程的退出码：

位运算复习链接：C语言初阶⑥（操作符详解）编程作业（算数转换）__GR的博客-CSDN博客

将 status 右移八位再按位与上 0xFF，即 (status >>8)&0xFF ，就可以提取到 status 的次低八位（这里应该得到子进程里exit（77）的77），编译运行：

验证： 通过提取 status 的最低7位，得到子进程的退出信号：

status 的低八位用于表示处理异常的地方，其中有 1 位是 core dump，最上面简单知道就行了。除去 core dump，剩余七位用于进程中的退出信号，这就是最低七位。

进程退出，如果异常退出，是因为这个进程收到了特定的信号。

我们虽然还没有开始讲解信号，但是我们前几张就介绍了 kill -9 这样的杀进程操作。

这个 -9 我们当时说了，就是一个信号，发送该信号也确实可以终止进程。

刚才我们讲的 wait/waitpid 和次低八位的时侯，都是关于进程的正常退出。

如果进程异常退出呢？我们来模拟一下进程的异常退出（就是使用kill -9）。

代码演示：模拟异常退出的情况，这里把子进程改成死循环，父进程一直等。

此时我们讲父进程打印的消息再增添一个 "退出信号"，也就是提取 status 的最低7位，我们想让低7位保留，高25位清0，让 status 按位与上 0x7F 即可

编译运行+监控：

while :; do ps ajx | head -1 && ps ajx | grep test| grep -v grep; echo "-------------------------------------------"; sleep 1; done

一直在运行，不终止，再开一个窗口，输入kill -9信号终止子进程：

这里一直阻塞式等待的父进程等待到子进程退出后也开始运行，并且成功打印退出信号

代码跑完结果是什么已经不重要了，我们最关心的是因为什么原因退出的。

当进程收到信号时，就代表进程异常了。进程程出，如果是异常退出，是因为该进程收到了特定的信号。其实除了 9 号信号还有很多信号，输入 kill -l 就可以查看这些：

比如遇到的除零警告：

编译运行：

while :; do ps ajx | head -1 && ps ajx | grep test| grep -v grep; echo "-------------------------------------------"; sleep 1; done

这时成功打印 8 号退出信号：SIGFPE（Float Pointer Error）

实际上，我们在编程学习中遇到的程序崩溃，程序一崩溃程序就退出了，今天在我们操作系统的角度来看，这就是进程终止。其实是因为错误而导致了软硬件错误，操作系统通过发送信号的方式把进程杀掉了。至于操作系统凭什么可以终止，又是怎么发信号的？又是如何终止的？详细的过程是什么？这些问题后面会讲。

打印子进程ID和退出信号还要进行位运算，这么麻烦是不是有点挫？所以Linux 已经给我们提供了一些宏供我们直接调用。它们是 WEXITSTATUS 和 WIFEXITED，实现就是和上面位运算一样的

WIFEXITED(status): 若为正常终止子进程返回的状态，则为真（查看进程是否是正常退出）

（w是wait，w if exit ）

WEXITSTATUS(status): 若 WIFEXITED 非零，提取子进程退出码（查看进程的退出码）

（w是wait，w exit status）