最全的Linux教程，Linux从入门到精通
======================
-
linux从入门到精通(第2版)
-
Linux系统移植
-
Linux驱动开发入门与实战
-
LINUX 系统移植 第2版
-
Linux开源网络全栈详解 从DPDK到OpenFlow
第一份《Linux从入门到精通》466页
====================
内容简介
====
本书是获得了很多读者好评的Linux经典畅销书**《Linux从入门到精通》的第2版**。本书第1版出版后曾经多次印刷，并被51CTO读书频道评为“最受读者喜爱的原创IT技术图书奖”。本书第﹖版以最新的Ubuntu 12.04为版本，循序渐进地向读者介绍了Linux 的基础应用、系统管理、网络应用、娱乐和办公、程序开发、服务器配置、系统安全等。本书附带1张光盘，内容为本书配套多媒体教学视频。另外,本书还为读者提供了大量的Linux学习资料和Ubuntu安装镜像文件，供读者免费下载。
本书适合广大Linux初中级用户、开源软件爱好者和大专院校的学生阅读，同时也非常适合准备从事Linux平台开发的各类人员。
需要《Linux入门到精通》、《linux系统移植》、《Linux驱动开发入门实战》、《Linux开源网络全栈》电子书籍及教程的工程师朋友们劳烦您转发+评论
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
【写在前面】
本文主要学习理解 fork 的返回值、写时拷贝的工作细节、为什么要存在写时拷贝；进程退出码、进程退出的场景及常见的退出方法、对比 man 2 _exit 和 man 3 exit；进程终止、操作系统怎么进行释放资源、池的概念；进程等待的价值、进程等待的方法 wait 和 waitpid(常用)、int* status、阻塞和非阻塞、如何理解等待、W
IFEXITED、WEXITSTATUS、WTERMSIG;什么是进程替换 && 为什么要进程替换、替换原理、7个exec系列的替换函数、模拟shell解释器；
一、进程创建
现阶段我们知道进程创建有如下两种方式，其实包括在以后的学习中这两种方式也是最常见的：
- 命令行启动命令 (程序、指令等)。
- 通过程序自身，fork 的子进程。
💦 fork函数
在 linux 中 fork 函数是非常重要的函数，它从已存在的进程中创建一个新进程。新进程为子进程，而原进程为父进程。
#include<unistd.h>
pid_t fork(void);
返回值：子进程返回 0，父进程返回子进程的 pid，出错返回 -1。
现在我们知道父进程被创建时，是有自己的 PCB、地址空间、页表的，在系统层面是通过用户级页表来维护地址空间和物理内存之间的映射关系的，而父进程只需要根据 PCB，找到地址空间，通过地址空间这样的窗口找到资源。不论是进程还是地址空间，它都是某种 struct 结构体变量，其中就包含很多属性和属性值。父进程 fork 时，子进程是以父进程为模板，人话就是子进程的大部分属性和属性值是继承父进程的，而小部分是指子进程的调度时间要重置、子进程的 pid、ppid 以及兄弟的要重置。其中上面的 PCB、地址空间、页表都在内核里由操作系统维护的，这也就意味着我们只需要调用操作系统提供的接口 fork，而具体工作细节由操作系统完成。注意进程的创建看起来是由父进程完成的，实际并不是父进程创建子进程，而是父进程通过调用 fork 函数开始了创建新进程的过程，本质进程还是由操作系统创建的。
进程调用 fork 时，控制逻辑就由用户层转移至内核，内核做：
- 分配新的内存块和内核数据结构给子进程。
- 将父进程部分数据结构内容拷贝至子进程。
- 添加子进程到系统进程列表当中。
- fork 返回，调度器调度。
💦 fork函数的返回值
- 如下代码运行后共创建了多少个子进程，它的之间的关系是啥 ❓
当我们看到这样的结果时，也不要奇怪，这是由调度器决定的。这里 4407 fork 了 4409 和 4408，此时 4407 第 1 次 fork 的进程 4408 还要在 fork 4410。
这里共创建了 4 个子进程，其中 2714 fork 之后，创建了 2715 进程，最后 2714 和 2715 会再 fork 2716 和 2717。这里就算是 2717 进程，对于 test.c 中所有的代码都是共享的，只不过不会执行它以上的代码，其中 2717 进程是通过程序计数器 eip 指针知道自己该执行哪行代码的。
- 一般我们不会让父子进程做同样的事 ❓
结合《Linux进程概念——上》至现在的认识，我们知道 fork 是一个系统函数，其中它会完成创建 pcb，生成 pid、创建地址空间、创建页表、构建映射关系、将子进程的 pcb 链入调度队列、返回 pid 等工作，在返回之前，这些工作看起来是由父进程完成的，我们曾经说过函数在返回时，函数的主要逻辑已经执行完了。
父进程的 pid 是 29459，子进程的 pid 是 29460。子进程的 pid 并不是由父进程给予的，包括父进程的 pid 也不是父进程的父进程给予的，而是由操作系统给予的。也就是说进程的创建看起来是由父进程创建的，但其实并不是，而是父进程通过调用 fork 函数开始了创建新进程的过程，本质任何进程的创建还是要由操作系统去完成的。
我们根据 fork 的返回值，来执行不同的逻辑流。从这里我们需要回答两个问题：
为啥 fork 同时有两个返回值和用于接收 fork 返回值的 ret 变量是怎么做到 ret == 0 && ret > 0 ❓
子进程创建之后，父子进程是共享代码的，我们认定 return 是代码，是和父子进程共享的代码，所以当我们父进程 return 时，这里的子进程也要 return，所以说这里的父子进程会 return 2 个值。这里 pid_t ret = fork()，父进程调用 fork，在 return 时，子进程已经创建出来了，那么父进程就 return 子进程的 pid 来初始化 ret 局部变量，随后子进程就 return 0 ，此时必定是通过写时拷贝来完成数据的各自私有，虽然父子进程的 &ret 是一样的，但是物理内存一定是两块不同的空间。 当我们理解了为啥同一个变量，却可以是两个不同的值后，再看 fork 为啥会有两个返回值时就有了新的理解角度。
注意不是 fork 创建子进程，并写时拷贝，而是 fork 创建子进程之后，父子谁先写入谁就写时拷贝，这里发生写时拷贝的原因是父子进程 return 的值用于初始化局部变量 ret 了。
角度一 (好理解，因为不用理解写时拷贝)：父子进程会使 fork return 2 个值。
角度二 (较为准确)：返回时发生了写时拷贝。
最后我们就可以明确了写时拷贝的价值就是保证父子进程的独立性。
💦 写时拷贝
写时拷贝是一种机制或者策略，好比打仗时的敌退我打，敌进我撤，它根据实时情况来完成既定规则。同理写时拷贝是根据父和子谁先写入的实时情况来完成拷贝的，它是一种延时操作的策略。
通常，父子代码共享，父子不写入时，数据也是共享的，且它们都是只读的，当任意一方试图写入，一般情况下程序就会报错终止了 (这里的报错是系统层面的，但因为这里是父子关系，操作系统就需要做拦截工作)，所以操作系统便以写时拷贝的方式生成一份副本于内存，修改页表的映射关系，并且更改权限为可读可写。具体见上图：
这里要强调的是这里的写时拷贝是针对数据的写时拷贝，这里留一个疑问 —— 代码会发生类似的写时拷贝的问题吗 ❓
答案是会的，在下面的进程替换会说明。
为什么存在写时拷贝 ❓
- 写时拷贝是为了保证父子进程的独立性。
- 节省内存和系统资源，提高 fork 的效率，减少 fork 失败的概率。
父子进程创建时，所有数据直接各自拷贝一份不行吗 ❓
很明显，不使用写时拷贝也可以保证父子进程的独立性，为啥还要费劲使用写时拷贝。其根本原因是 a) 所有的数据，父和子并不是都必须写入数据，有可能它们仅仅需要读取，而此时的各自拷贝是没有意义的，而且会浪费内存和系统资源。b) fork 时，创建数据结构，如果还要将数据拷贝一份，那么 fork 的效率一定会降低。c) fork 本质就是向系统申请更多的内存资源，资源申请多了，fork 有可能就会失败。
💦 fork常规用法
- 一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求，这个会在《Linux 网络编程》中学习。
- 一个进程要执行一个不同的程序。例如子进程从 fork 返回后，调用 exec 函数，这个会在本文中学习。
💦 fork调用失败的原因
fork 是操作系统的接口，所以失败的原因一定是系统级别的原因。
- 系统中已经存在太多的进程了。
- 实际用户创建的进程超过了限制。
二、进程终止
为什么 main 函数中，总是 return 0，return 其它值可以吗 ❓
对于 main 函数的返回值，我们称之为进程退出码，它代表进程退出后，结果是否正确，通常进程退出码为 0 代表成功，!0 代表其它含义，如果你愿意你也可以 return 其它值。大部分情况下，main 函数跑完后，默认结果是正确的，所以以前返回的都是 0。
main 函数 return 的值给谁看 ❓
其实 main 函数 return 的值是给系统看的，以此来判断进程执行后的结果。
程序员怎么看 main 函数 return 的值 ❓
echo $?用来保存最近一次程序运行结束时退出码的值是多少。
💦 进程退出的场景
此文重点学习前两种场景，第三种会学习一部分，后面信号再补充：
- 代码运行完毕，结果正确，退出码为 0
- 代码运行完毕，程序没有崩溃，但因为逻辑问题，结果不正确，退出码为 !0。
- 代码没有运行完毕，程序非正常结束，包括人为终止，此时退出码没有意义。
在之前我们经常会遇到第二种场景，但是它返回的也是 0 ❓
说明之前写的代码并不好，更加规范的写法是如果结果符合预期就返回 0，否则返回 !0。
退出码 ❓
退出码可以人为的定义，比如 0 表示成功，1 表示链表翻转时头节点传野指针等，也可以使用系统的错误码列表。当程序运行失败时，毫无疑问我们最关心的是为什么会失败。比如你的妈妈很严厉，而你今天考试得了零分，这是一次很失败的考试经历，你妈妈知道后，问你为什么失败，此时你就得告诉妈妈失败的原因。人最擅长的是处理字符串，所以你说是因为迟到了。而计算机擅长处理整型类型的数据，所以才有了 0, 1, 2, 3 等这样的退出码。所以计算机需要将 int 类型的错误码转换为 string 类型的错误码，以供我们认识。
演示 int 到 string 错误码之间的映射 ❓
你可以使用系统错误码，虽然 strerror 有 100 多条错误码，但是这种方式还是受限的。strerror 可以实现 int 到 string 错误码之间的映射。
所有的父进程都关心子进程退出结果 ❓
大部分情况下父进程关心子进程的退出码的，因为父进程费了很大的劲把子进程创建出来干活，活干的怎么样，父进程得知道。但并不是所有的父进程都关心子进程退出结果。而有时父进程也不关心子进程的退出码，比如说公司老板想开除我，然后 hr 找我谈，说你的合同到期了，可以走了，再干下去你也没工资，此时你肯定会走，hr 也不需要关心。换言之，我们后面大部分遇到的都是父进程关心子进程退出码的情况，而很小部分会碰到父进程不需要关心子进程的退出结果。
进程非正常结束 ❓
野指针、除 0、越界等都可能导致进程非正常结束，父进程也要关心这种情况，但此时退出码是无意义的。好比，今天考试，因为肚子痛考了 0 分，那么这个理由是可以被妈妈信服的。但因为考试作弊被抓，考了 0 分，这个其实不算理由，因为你都不是正常考完的，后面你再解释的所有理由就毫无意义。一般这里异常终止时，是由信号终止的，因为涉及信号，不是本文的重点，所以后面再详谈。
💦 进程常见的退出方法
1、正常退出
- main 函数 return
可以看到只有 main 函数的 return 才是结束进程，非 main 函数的 return 是结束函数。
- 任何函数 exit
对于退出的函数，有库函数和系统函数两个版本，这里我们使用库函数就足够了：
任何函数 exit，都表示直接终止进程：
2、异常退出
- ctrl + c，信号终止
3、_exit函数
这是系统提供的接口，它的原型同库里的 exit 函数，那么系统的 _exit 和 库函数的 exit 有什么区别 ❓
- exit 在退出时同默认的 return，会进行后续资源处理，包括刷新缓冲区。
_exit 在退出时，不会进行后续资源处理，直接终止进程。
-
exit 最后也会调用 _exit，但在这之前，exit 还做了其它工作 ❗
- 执行用户通过 atexit 或 on_exit 定义的清理函数。
- 关闭所有打开的流，所有的缓存数据均被写入。
- 调用 _exit。
-
main 函数里都不写 return 和 exit，退出码是啥 ❓
理论上这里的退出码是未定义的、随机的，但实际上，得到的退出码是 0，因为你的 main 函数里总会调用其它函数，成功后，遗留的历史数据是会充当返回值去返回的。
main 函数里啥也不做，可以看到退出码依旧是 0，不必太纠结，这个本就是标准未定义的。
💦 如何理解进程终止
站在操作系统角度，如何理解进程终止 ❓
之前我们说过，进程创建，操作系统要做的事：把程序加载到内存、创建对应的 pcb、地址空间、页表、构建地址空间到物理内存的映射关系、把进程放在运行队列调度。那么进程终止肯定是曾经进程创建的相反工作，核心是归还资源。注意在 C++ 中会谈 STL 底层重点容器的原理，会谈及内存处理的一些策略，这里希望能两者对照起来。
释放曾经为了管理进程所维护的所有的数据结构对象。
这里的释放，在操作系统里，并不是真的把数据结构对象销毁，而是设置为不用状态，然后保存起来，如果这样不用的对象多了，就有了一个数据结构池。
池 ❓
我们在 C/C++ 中都使用过库函数 malloc、操作符 new 来申请过内存，内存是硬件，malloc、new 一定是向操作系统申请，而这个过程相对比较耗时。比如你是某某市的首富的儿子，要去银行贷款 100 万，银行会让你填张表、排队、审核你的条件，最后说 5 天之后放款。你的钱用完了，还需要去银行再贷款 200 万，又重复贷款流程。你的钱又用完了，又还需要去银行再贷款 300 万，又重复贷款流程。那么对银行来讲，只要你不嫌麻烦，银行当然没问题，可是实际对你来讲，每次贷款都需要等很长的时间，效率太低，所以干脆你可以直接贷款 1000 万，这 1000 万就叫资金池，后面你想用 100 万、200 万，就不用去找银行了，你直接从你的资金池里拿，后面你盈利了，就把钱还给银行。 这就意味着你一次申请一大块内存，可以节省你频繁的从用户空间向内核空间要资源的过程，我们把申请的一大块空间叫做内存池，所以池本质是为了减少频繁向内核空间要资源的过程，提高用户的效率。
我们创建进程，就需要生成 task_struct、mm_struct 等各种数据结构，那么就需要往已经申请好的内存池空间来存储，此时需要对该空间进行强制类型转换为 task_struct*，若每个进程创建生成的数据结构，都要进行强制类型转换，太麻烦了，内存池也没规定必须得是这样的结构。所以这里使用了一个链表结构，里面存储的是没有人使用的 task_struct 等数据结构，如果要释放进程所维护的数据结构，那么就把数据结构对象链入链表中，如果进程创建，需要对应的数据结构，就直接从数据结构池里拿，这样就不用申请空间和强制类型转换了。我们可以维护各种各样的数据结构，整体我们称之为数据结构池。所以释放的过程就是把数据结构对象归还给数据结构池，数据结构池就解决了频繁申请空间和强制类型转换。
所以我们就可以把不要的数据结构，包括里面的数据一起保留在废弃队列里，创建进程时，先从废弃队列里找，如果有合适的节点，就直接拿去用，如果不够，就再重新开辟。好比有 100 个实习生要在这几天陆续入职公司，公司会为每个实习生配电脑，如果每来一个实习生，公司就去京东上买台电脑，这样做一方面下单、邮寄，效率太低了；另一方面，每一个人都用新电脑，对于公司来说成本太高了。所以当一个人离职时，并不是把这个人所有信息都销毁、其所使用的电脑卖掉，而是把所有不用的电脑放在一起，当有新的员工入职时，直接从电脑池里拿。
所以在 Linux 中，这种释放规则叫做 Slab 分派器，它的核心工作是完成在 Linux 内核中数据结构级别的内存分配。
2. 释放程序代码和数据占用的内存空间。
所以有了上面的理解，我们就知道这里的释放不是把代码和数据清空，而是把内存设置为无效。比如你从 U 盘里拷贝一个 3G 的电影到你的电脑，你会发现速度特别慢，拷贝 30 秒钟，后来你看完了，你花了 1 秒钟删掉它，这里就有个问题：
如果删除的过程和写入的过程是一个相似的、相反的逻辑，写的过程是在磁盘上把数据以二进制写好，删的过程是相反，那么它们所花的时间应该是相同的 ❓
实际我们在进行删除时，就是对所对应的空间标识为无效，这就意味着它是可以被覆盖的，写入新数据的同时就是在覆盖老数据。所以这里想说的是计算机里的释放并不是真的释放，要么就是利用 Slab 分派器以数据结构的方式缓存起来，要么就是把空间设置为无效，你都可以进行二次覆盖。也就是说以前我们经常看到的把文件删除后，文件就跑到回收站里了，此时并不是真正的删除，而是设置为无用状态，本质是临时删除放进回收站的文件只是在注册表中状态被改为无用状态，而再对回收站中的文件进行删除时，就意味着文件在注册表中被除名，但是文件的数据仍在，所以，即使我们把回收站的文件清空了，照样可以通过注册表来恢复文件。
内存空间怎么做到无效 ❓
内存也要进行管理，其也有对应的数据结构，如果没有人指向这个内存，此时这个内存就是无效的，后面我们学习文件以及多进程时会证明内存无效。
3. 取消曾经该进程的链接关系。比如我是子进程，我有 1 个父进程，3 个兄弟进程，除了所有进程本身是用双链表链接的，这里与父和子也有链接关系，所以我要离开了，就要把之前的关系统统去掉。
三、进程等待
💦 进程等待的必要性
进程等待当然是必要的。之前讲过，子进程退出，父进程如果不管不顾，就可能造成 “ 僵尸进程 ” 的问题，进而造成内存泄漏。另外，进程一旦变成僵尸状态，那就刀枪不入，“ 杀人不眨眼 ” 的kill -9也无能为力，因为谁也没有办法杀死一个已经死去的进程。 最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息。
- 回收僵尸进程，避免内存泄漏。
- 需要获取子进程的运行结束状态和运行结果。
这一点不是必须的，需要就获取，不需要就不要获取。注意区分运行状态和运行结果，两者是有区别的。
- 尽量保证父进程要晚于子进程退出，可以规范化进行资源回收。
将来我们写代码时，所有要做的事情都交给子进程，子进程把事办完了，由父进程统一回收。这点其实是与编码相关的策略，而并非属于系统级别的要求。
信号部分结束我们就可以知道有一种方案可以让父进程既不等子进程又没有内存泄漏的风险。
💦 进程等待的方法
在一些复杂的场景下，相比 wait，waitpid 使用的更多，也能满足更多的需求。
1、wait方法
#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int* status);
功能：
等待任意一个子进程(可以有多个)，当子进程退出，wait就可以返回
返回值：
成功则返回被等待进程的pid，失败则返回-1。
参数：
输出型参数，获取子进程退出状态，不关心则可以设置为NULL。wait 的参数 int* status 会重点在下面的 waitpid 学习。
✔ 测试用例一：
父进程等待子进程退出后，wait 获取子进程的 pid。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
pid_t id = fork();
if(id < 0)
{
perror("fork");
return 1;
}
else if(id == 0)
{
int count = 5;
while(count)
{
printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
sleep(1);
}
printf("child quit...\n");
exit(0);
}
else
{
printf("father is waiting...\n");
pid_t ret = wait(NULL);
printf("father is wait done, ret: %d\n", ret);
}
return 0;
}
💨运行结果：
✔ 测试用例二：
相比测试用例一，更直观的等待，并维持了一段时间的僵尸，进程从无到有，从有到无。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
pid_t id = fork();
if(id < 0)
{
perror("fork");
return 1;
}
else if(id == 0)
{
int count = 5;
while(count)
{
printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
sleep(1);
}
printf("child quit...\n");
exit(0);
}
else
{
printf("father is waiting...\n");
sleep(10);
pid_t ret = wait(NULL);
printf("father is wait done, ret: %d\n", ret);
sleep(3);
printf("father quit...\n");
}
return 0;
}
💨运行结果：
监控脚本：while :; do ps ajx | head -1 && ps ajx | grep process | grep -v grep; sleep 1; echo "####################"; done (grep -v grep 查找所有非 grep)
✔ 测试用例三：
fork 5 个子进程后，父进程依次等待，并回收僵尸进程。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
int i = 0;
while(i < 5)
{
pid_t id = fork();
if(id < 0)
{
perror("fork");
return 1;
}
if(id == 0)
{
int count = 5;
while(count)
{
printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
sleep(1);
}
printf("child quit...\n");
exit(0);
}
i++;
}
for(i = 0; i < 5; i++)
{
printf("father is waiting...\n");
sleep(10);
pid_t ret = wait(NULL);
printf("father is wait done, ret: %d\n", ret);
sleep(3);
printf("father quit...\n");
}
return 0;
}
💨运行结果：
现象 ❓
在 1 秒内，父进程很快的就创建了 5 个子进程，并开始走 for 循环，然后输出 father is waiting…，随后就休眠 10 秒。5 秒前，5 个子进程开始走 while 循环中的 while 循环，随后全部退出。5 秒后父进程开始每隔 13 秒循环的回收僵局进程。
子进程僵尸了，父进程也退出了 ❓
此时 ps ajx 能否看到僵尸进程是不确定的。因为父进程退出，子进程会被操作系统领养。那么这个僵尸进程是在被操作系统领养后立马回收，还是积累到一定的僵尸进程再回收，这是由操作系统的策略决定的，同时也跟当前操作系统的状态有关系，如果操作系统发现内存资源已经很紧张了，就会提前回收。
一般而言，我们需要 fork 之后，让父进程进行等待 ❗
2、waitpid方法
#include<sys/types.h>
#include<sys/wait.h>
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相等的子进程；
因为父进程返回的是子进程的pid，所以父进程就可以等待指定的子进程，等待本质是管理的一种方式；
status，
输出型参数，我们传了一个整数地址进去，最终通过指针解引用把期望的数据拿出来。与之对应的是实参传递给形参是输入型参数；
WIFEXITED(status)，查看进程是否正常退出，是则真，不是则假；
WEXITSTATUS(status)，查看进程退出码，需要WIFEXITED(status)返回true，WIFEXITED(status)正常退出则返回true；
WTERMSIG(status)，返回导致子进程终止的信号的编号，需要WIFSIGNALED(status)返回true，WIFSIGNALED(status)子进程被信号终止返回true；
options，
WNOHANG，若pid指定的子进程没有结束，则waitpid()函数返回0，本次不予以等待，需要我们再次等待；若非正常结束，则返回该子进程的ID；或者小于0，失败了。
0，阻塞式等待，同wait————子进程没退出、回收，父进程继续等待；
status ❓
- wait 和 waitpid，都有一个 status 参数，该参数是一个输出型参数，由操作系统填充。
- 如果传递NULL，表示不关心子进程的退出状态信息。
- 否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
- status 不能简单的当作整型来看待，可以当作位图来看待，具体细节如下图 (目前只研究 status 低16 比特位)。
阻塞和非阻塞 ❓
这个概念我们是第一次接触，也不会深入，后面再学习文件和网络时会经常接触。如果 waitpid 中的 options 传 WNOHANG ，那么等待方式就是非阻塞；如果传 0，那么等待方式就是阻塞。
比如你的学习很差，所以打电话给楼上学习好的同学张三，说：张三，你下来，我请你吃个饭，然后你帮我复习一下。张三说：行，没问题，但是我在写代码，半个小时之后再来。一般一个班，学习好的人总是少数，所以你怕你电话一挂，有人又跟张三打电话求助，导致你不能及时复习，所以你又跟张三说：张三，你电话不要挂，你把电话放你旁边，我喜欢看你写代码的样子。然后你什么事都不做，就在那等待，直到张三下来。当然现实中很少有这种情况，但是这样的场景是存在的，一般是比较紧急的情况，比如你爸打电话让你做件事且告诉你不要挂电话。此时张三不下来，电话就不挂就类似于调用函数，这种等待方式就叫做阻塞等待。我们目前所调用的函数，全部是阻塞函数，不管是你自己写的、库里的、系统的，因为我们目前写的代码都是一跑就结束，所以压根就遇不到非阻塞的场景。阻塞函数最典型的特征是调用 ➡ 执行 ➡返回 ➡ 结束，其中调用方始终在等待，什么事情都没做。
又比如，你跟张三说：明天要考试了，一会我们去吃个饭，然后去自习室，你帮我复习下。张三说：没问题，但是我在写代码，你得等我下。你说：行吧，我在食堂等你，然后挂电话。过了两分钟，你给张三打电话说：张三，你来了没。张三说：我还得一会，你再等下。你说：行吧，然后挂电话。又过了两分钟，你又给张三打电话说：张三，你来了没 … … 。你不断重复的给张三打电话，这种场景在生活中比较多，我们经常催一个人做一件事时，他老是不动，你就不断重复给他打电话。你本质并不是给张三打电话，而是检测张三的状态，张三有没有达到我所期望的状态，每次检测张三是不一定立马就就绪的，如他有没有写完、开始下楼等。这里的检测张三的状态，只是想查看进度，所以这里打电话过程并不会把我卡住，我通过多次打电话来检测张三的进度。每次打电话挂电话的过程就叫做非阻塞等待。 我们只要看了它的状态不是就绪，就立马返回。这种基于多次的非阻塞的调用方案叫做非阻塞轮询检测方案。
为什么现实世界中大部分选择非阻塞轮询 ❓
这种高效体现在：主要是对调用方高效，你给张三打电话，张三就要 10 分钟，那就是 10 分钟，类似于计算机，你再怎么催都没用，所以我们就不会死等，我们可以先做其它的事，反正不会让因为等待你，而让我做不了事情。
那为什么我们写的代码大部分都是阻塞调用 ❓
根本原因在于我们的代码都是单执行流，所以选择阻塞调用更简单。
为什么是 WNOHANG ❓
在服务器资源即将被吃完时，卡住了，我们一般称服务器hang住了，进而导致宕机。所以 W 表示等待，NO 表示不要，HANG 表示卡了，所以这个宏的意思是等待时不要卡住。
如何理解父进程等子进程中的 “ 等 ” ❓
所谓的等并不是把父进程放在 CPU 上，让父进程在 CPU 上边跑边等。本来父子进程都在运行队列中等待 CPU 运行，当子进程开始被 CPU 运行后，就把父进程由 R 状态更改为 !R 状态，并放入等待队列中，此时父进程就不运行了，它就在等待队列中等待。当子进程运行结束后，操作系统就会把父进程放入运行队列，并将状态更改为 R 状态，让 CPU 运行，这个过程叫做唤醒等待的过程。
操作系统是怎么知道子进程退出时就应该唤醒对应的父进程呢 ❓
wait 和 waitpid 是系统函数，是由操作系统提供的，你是因为调用了操作系统的代码导致你被等待了，操作系统当然知道子进程退出时该唤醒谁。
这里，我们只要能理解等待就是将当前进程放入等待队列中，将状态设置为 !R 状态。所以一般我们在平时使用计算机时，肉眼所发现的一些现象，如某些软件卡住了，根本原因是要么进程太多了，导致进程没有被 CPU 调度；要么就是进程被放到了等待队列中，长时间不会被 CPU 调度。我们曾经在写 VS 下写过一些错误代码，一旦运行，就会导致 VS 一段时间没有反应。所谓的没有反应就是因为程序导致系统出现问题，操作系统在处理问题区间，把 VS 进程设置成 !R 状态，操作系统处理完，再把 VS 唤醒。
验证子进程僵尸后，退出结果会保存在 PCB 中 ❓
可以看到在 Linux 2.6.32 源码中，task_struct 里包含了退出码和退出信息。
✔ 测试用例一：
同 wait 测试用例二。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
pid_t id = fork();
if(id == 0)
{
int count = 5;
while(count)
{
printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
sleep(1);
}
printf("child quit...\n");
exit(0);
}
//father
sleep(8);
pid_t ret = waitpid(id, NULL, 0);//只有一个进程,同waitpid(-1, NULL, 0)
printf("father wait done, ret: %d\n", ret);
sleep(3);
return 0;
}
💨运行结果：
✔ 测试用例二：
父进程 fork 派生一个子进程干活，父进程通过 status 拿到子进程的退出码，可以知道子进程把活做的怎么样。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
pid_t id = fork();
if(id == 0)
{
int count = 5;
while(count)
{
printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
sleep(1);
}
printf("child quit...\n");
//exit(0);//做好了
exit(123);//没做好
}
//father
int status = 0;
pid_t ret = waitpid(-1, &status, 0);
int code = (status >> 8) & 0xFF;
printf("%d\n", status);
printf("father wait done, ret: %d, exit code: %d\n", ret, code);
if(code == 0)
{
printf("做好了\n");
}
else
{
printf("没做好\n");
}
return 0;
}
💨运行结果：
(31488)10 = (0111 1011 0000 0000)2 ;
0111 1011 0000 0000 >> 8 = 0111 1011;
(0111 1011)2 = (123)10 ;
子进程已经退出了，子进程的退出码放在哪 ❓
换句话说，父进程通过 waitpid 要拿子进程的退出码应该从哪里去取呢，明明子进程已经退出了。子进程是结束了，但是子进程的状态是僵尸，也就是说子进程的相关数据结构并没有被完全释放。当子进程退出时，进程的 task_struct 里会被填入当前子进程退出时的退出码，所以 waitpid 拿到的 status 值是通过 task_struct 拿到的。
✔ 测试用例三：
针对测试用例二，父进程无非就是想知道子进程的工作完成的结果，那全局变量是否可以作为子进程退出码的设置，以此告知父进程子进程的退出码。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int code = 0;
int main()
{
pid_t id = fork();
if(id == 0)
{
int count = 5;
while(count)
{
printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
sleep(1);
}
printf("child quit...\n");
code = 123;
exit(0);
}
//father
int status = 0;
pid_t ret = waitpid(-1, &status, 0);
printf("father wait done, ret: %d, exit code: %d\n", ret, code);
if(code == 0)
{
printf("做好了\n");
}
else
{
printf("没做好\n");
}
return 0;
}
💨运行结果：
很显然，不可以。这里对于全局变量，发生了写时拷贝，在进程地址空间里我们说过父子是具有独立性的，虽然变量是同一个，但实际上子进程或父进程所写的数据，它们都是无法看到彼此的，所以不可能让父进程拿到子进程的退出结果。
✔ 测试用例四：
模拟异常终止 —— 野指针。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
pid_t id = fork();
if(id == 0)
{
int count = 5;
while(count)
{
printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
sleep(1);
//err
int\* p = 0x12345;
\*p = 100;
}
printf("child quit...\n");
exit(123);
}
//father
int status = 0;
pid_t ret = waitpid(-1, &status, 0);
int code = (status >> 8) & 0xFF;
int sig = status & 0x7F;//0111 1111
printf("father wait done, ret: %d, exit code: %d, sig: %d\n", ret, code, sig);
return 0;
}
💨运行结果：
子进程崩溃后，立马退出，变成僵尸，并不会影响父进程，这叫做父子具有独立性，父进程等待成功 (不管你是正常还是非正常退出)，随后进行回收。此时子进程的退出码是无意义的，子进程的异常终止导致父进程获得了子进程退出时的退出信号，我们发现它的信号是第 11 号信号(SIGSEGV)，它一般都是段错误。
✔ 测试用例五：
模拟异常终止 —— 使用kill -9信号亲手杀死子进程。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
pid_t id = fork();
if(id == 0)
{
int count = 50;
while(count)
{
printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
sleep(1);
}
printf("child quit...\n");
exit(123);
}
//father
int status = 0;
pid_t ret = waitpid(-1, &status, 0);
int code = (status >> 8) & 0xFF;
int sig = status & 0x7F;//0111 1111
printf("father wait done, ret: %d, exit code: %d, sig: %d\n", ret, code, sig);
return 0;
}
💨运行结果：
当我们把正在运行的子进程亲手杀掉后，父进程立马做回收工作，此时退出码是什么已经不重要了，父进程拿到的信号是第 9 号信号(SIGKILL)，此时我们就知道子进程连代码都没跑完，是被别人杀掉才退出的。
✔ 测试用例六：
父进程完整的等待子进程的全过程。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
pid_t id = fork();
if(id == 0)
{
int count = 5;
while(count)
{
printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
int\* p = 0x12345;
\*p = 100;
sleep(1);
}
printf("child quit...\n");
exit(123);
}
//father
int status = 0;
pid_t ret = waitpid(id, &status, 0);
if(ret > 0)
{
printf("wait success!\n");
if((status & 0x7F) == 0)//正常退出
{
printf("process quit normal!\n");
printf("exit code: %d\n", (status >> 8) & 0xFF);
}
else//信号退出
{
printf("process quit error!\n");
printf("sig: %d\n", status & 0x7F);
}
}
return 0;
}
💨运行结果：
正常，
异常，
✔ 测试用例七：
可以看到需要对数据进行加工才可以获取退出码和退出信号，比较麻烦，我们一般也不会自己加工。其实系统有提供一些宏(函数)，可以直接使用，我们主要学习 3 个 —— WIFEXITED(status)、WEXITSTATUS(status)、WTERMSIG(status)，其相关介绍可在 waitpid 手册里查找。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
pid_t id = fork();
if(id == 0)
{
int count = 5;
while(count)
{
printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
//err
//int\* p = 0x12345;
//\*p = 100;
sleep(1);
}
printf("child quit...\n");
exit(123);
}
//father
int status = 0;
pid_t ret = waitpid(id, &status, 0);
if(ret > 0)
{
printf("wait success!\n");
if(WIFEXITED(status))//查看进程是否正常退出,是则真,不是则假。同(status & 0x7F) == 0
{
printf("normal quit!\n");
printf("quit code: %d\n", WEXITSTATUS(status));//查看进程退出码。同(status >> 8) & 0xFF
}
else
{
printf("process quit error!\n");
printf("sig: %d\n", WTERMSIG(status));//查看导致子进程终止的信号的编号。同status & 0x7F
}
}
return 0;
}
💨运行结果：
正常，
异常，
✔ 测试用例八：
非阻塞等待。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
pid_t id = fork();
if(id == 0)
{
int count = 3;
while(count)
{
printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
//err
最全的Linux教程，Linux从入门到精通
======================
1. **linux从入门到精通(第2版)**
2. **Linux系统移植**
3. **Linux驱动开发入门与实战**
4. **LINUX 系统移植 第2版**
5. **Linux开源网络全栈详解 从DPDK到OpenFlow**
第一份《Linux从入门到精通》466页
====================
内容简介
====
本书是获得了很多读者好评的Linux经典畅销书**《Linux从入门到精通》的第2版**。本书第1版出版后曾经多次印刷，并被51CTO读书频道评为“最受读者喜爱的原创IT技术图书奖”。本书第﹖版以最新的Ubuntu 12.04为版本，循序渐进地向读者介绍了Linux 的基础应用、系统管理、网络应用、娱乐和办公、程序开发、服务器配置、系统安全等。本书附带1张光盘，内容为本书配套多媒体教学视频。另外,本书还为读者提供了大量的Linux学习资料和Ubuntu安装镜像文件，供读者免费下载。
**本书适合广大Linux初中级用户、开源软件爱好者和大专院校的学生阅读，同时也非常适合准备从事Linux平台开发的各类人员。**
> 需要《Linux入门到精通》、《linux系统移植》、《Linux驱动开发入门实战》、《Linux开源网络全栈》电子书籍及教程的工程师朋友们劳烦您转发+评论
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**[需要这份系统化的资料的朋友，可以点击这里获取！](https://bbs.csdn.net/topics/618542503)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
