最全的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行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
- 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
//int\* p = 0x12345;
//\*p = 100;
sleep(1);
}
printf("child quit...\n");
exit(123);
}
//father 非阻塞等待
int status = 0;
while(1)
{
pid_t ret = waitpid(id, &status, WNOHANG);
if(ret == 0)//等待失败,继续等待
{
printf("wait next!\n");
printf("father do other thing!\n");
}
else if(ret > 0)//等待成功
{
printf("wait success, ret: %d, code: %d\n", ret, WEXITSTATUS(status));
break;
}
else//等待失败,真的失败
{
printf("wait failed!\n");
break;
}
}
//father 阻塞等待
//int status = 0;
//pid\_t ret = waitpid(id, &status, 0);
//if(ret > 0)
//{
// printf("wait success!\n");
// if(WIFEXITED(status))
// {
// printf("normal quit!\n");
// printf("quit code: %d\n", WEXITSTATUS(status));
// }
// else
// {
// printf("process quit error!\n");
// printf("sig: %d\n", WTERMSIG(status));
// }
//}
return 0;
}
💨运行结果:
三、进程替换
💦 为什么要进程替换 && 什么是进程替换
创建子进程的目的:
- 执行父进程的部分代码
我们之前所写的代码都属于这种情况。
- 执行其它程序的代码
不要父进程的代码和数据。所以我们要学习进程替换。
所以进程替换是为了子进程能够执行其它程序的代码;进程替换就是以写时拷贝的策略,让第三方进程的代码和数据替换到父进程的代码和数据,给子进程用,因为进程间具有独立性,所以不会影响父进程。以前我们说数据是可写的,代码是不可写的,现在看来代码确实是不可写的,但是接下来要把其它程序的代码放在内存里让子进程看到,以前子进程看到的是父进程的代码,现在有新的代码来了,此时也要对代码进行写时拷贝。99% 的情况是对数据进行写时拷贝,代码只读。1% 的情况代码依旧是只读,本质就是对父进程不可写,而子进程后续调用某些系统调用,实际是给子进程重新开辟空间,把新进程的代码加载,此时就不让子进程执行父进程的代码,这个过程叫做程序替换。
💦 替换原理
我们想让子进程里执行新的程序,可以一步到位在内存里重新开辟两块空间以加载新程序的代码和数据,再修改子进程页表的映射关系,之后父子就彻底脱离了,这个过程就是进程替换。
系统是如何做到重新建立映射关系的呢 ❓
当子进程里要加载新进程时,操作系统可以设置一些特殊信号让该进程对全部代码和数据的写入,子进程会自动触发写时拷贝,重新开辟空间,再重新把代码和数据加载。
在进行进程替换时,有没有创建新的进程 ❓
我们并不需要重新开辟新的 PCB、地址空间、页表,没有创建新进程的最有力证据是 pid 没变。所以我们曾经说过,程序要运行起来,必须先加载到内存,这句话当然没问题。但是反过来,程序只要加载到内存了,一定是变成一个进程,这句话有纰漏,因为进程是否是新创建是不一定的。不过大部分情况下是创建新进程的,进程替换是属于少数。
所以进程替换不会改变进程内核的数据结构,只会修改部分页表数据,然后把新进程的代码和数据加载至内存,重新构建页表映射关系,和父进程彻底脱离。
💦 替换函数
其实严格来说有7种以exec开头的系列函数,统称exec函数:
#include<unistd.h>
int execl(const chaar* path, const char* arg, ...);
int execlp(const char* file, const chr* arg, ...);
int execv(const char* path, char* const argv[]);
int execvp(const char* file, char* const argv[]);
int execle(const chra* path, const char* arg, ..., char* const envp[]);
int execve(const char* path, char* const argv[], char* const envp[]);
int execvpe(const char* file, char* const argv[], char* const envp[]);
这些函数的功能都是一样的,如果用 C++ 去设计这样的接口,一定是重载。这里是使用 C 去设计的,函数名的命名也有区分。下面我们会对这些接口进行演示,但实际在后面常用的也只是部分而已。
为什么 execve 要单独拎出来 ❓
虽然头文件都是 <unistd.h>,但实际上真正是系统提供函数只有 execve,其余的 6 个都是封装的,最后底层调用的依旧是 execve,这样做的原因是需要根据不同的用户来定制不同的使用场景。好比,大家最后吃的米饭都会转换成能量,但是有的人喜欢蛋炒饭、有的人喜欢肉丝炒饭。
💦 函数解释及使用
- 这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回
- 如果调用出错则返回 -1
- 所以 exec 函数只有出错的返回值而没有成功的返回值
✔ 测试用例一:
单进程,父进程亲自干活:
#include<stdio.h>
#include<unistd.h>
int main()
{
printf("my process begin!\n");
execl("/usr/bin/ls", "ls", "-a", "-l", "-i", NULL);
printf("my process end!\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)
{
printf("I am child, pid: %d, ppid: %d\n", getpid(), getppid());
execl("/usr/bin/ls", "ls", "-a", "-l", "-i", NULL);
exit(1);//这里一定是替换失败
}
//father
int status = 0;
pid_t ret = waitpid(id, &status, 0);
if(ret > 0)
{
printf("child status -> sig: %d, code: %d\n", status & 0x7F, (status >> 8) & 0xFF);
}
else
{
printf("wait error!\n");
}
return 0;
}
💨运行结果:
为什么图一没有输出 my process end ! && 图二的退出码是 0 ❓
因为在这之前 execl 已经程序替换了,所以 execl 后面的代码已经不是当前进程的代码了,所以图二获取到的退出码 0 是 ls 的退出码。换言之,一旦程序替换,你到底执行正确与否是取决于 ls 程序。
所以 exec 系列的函数不用考虑返回值,只要返回了,一定是这个函数调用或程序替换失败了。注意编程规范是父进程创建子进程干活。
先自我介绍一下,小编浙江大学毕业,去过华为、字节跳动等大厂,目前在阿里
深知大多数程序员,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年最新Linux运维全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上运维知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新
}
💨运行结果:
![在这里插入图片描述](https://img-blog.csdnimg.cn/b65b16c1702044ba8287c428f7438ebf.png)
![在这里插入图片描述](https://img-blog.csdnimg.cn/f46418f63871454f9e39ffe64e562f36.png)
为什么图一没有输出 my process end ! && 图二的退出码是 0 ❓
因为在这之前 execl 已经程序替换了,所以 execl 后面的代码已经不是当前进程的代码了,所以图二获取到的退出码 0 是 ls 的退出码。换言之,一旦程序替换,你到底执行正确与否是取决于 ls 程序。
所以 exec 系列的函数不用考虑返回值,只要返回了,一定是这个函数调用或程序替换失败了。注意编程规范是父进程创建子进程干活。
**先自我介绍一下,小编浙江大学毕业,去过华为、字节跳动等大厂,目前在阿里**
**深知大多数程序员,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!**
**因此收集整理了一份《2024年最新Linux运维全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。**
[外链图片转存中...(img-MuY7F2hy-1715003587737)]
[外链图片转存中...(img-5bXVXkwU-1715003587737)]
[外链图片转存中...(img-AP7QUYF9-1715003587737)]
[外链图片转存中...(img-7RlL5TWS-1715003587738)]
[外链图片转存中...(img-w7YDA9VR-1715003587738)]
**既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上运维知识点,真正体系化!**
**由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新**
**[需要这份系统化的资料的朋友,可以点击这里获取!](https://bbs.csdn.net/topics/618542503)**