标签：多个 计算机体系 快捷图标 内存数据 信息 字节码 僵尸 目的 路径名
1. 有关进程
1.1 什么是进程
我们在前面的课程就讲过这个问题，我们这里再来回顾下。
我们说，将程序代码从硬盘拷贝到内存上，在内存上动态运行的程序就是进程。
对比一下进程和程序：
存储位置 存在状态 运行过程
程序 硬盘 静态的 无运行的过程
进程 存在内存中，它是从磁盘上的程序考过来的副本 动态的 有运行的过程，所以进程有生有死
1.2 多进程并发运行
有OS支持时，会有很多的进程在运行，这些进程都是并发运行的。
什么是并发运行？
就是CPU轮换的执行，当前进程执行了一个短暂的时间片（ms）后，切换执行另一个进程，如此循环往复，由于时间片很短，
在宏观上我们会感觉到所有的进程都是在同时运行的，但是在微观上cpu每次只执行某一个进程的指令。
图：
当然我们这里说的单核cpu的情况，如果cpu是多核的话，不同的cpu核可以同时独立的执行不同的进程，这种叫并行运行。
所以当cpu是多核时，并发与并行是同时存在的。
1.3 进程ID（PID）
1.3.1 什么是PID
基于OS运行的进程有很多，OS为了能够更好地管理进程，为每个进程分配了一个唯一的编号（非负整数），这个编号就是PID，
P就是process——进程的意思。
这记好比公安局给每个人分配了一个唯一的身份证号（ID）是一样的。
ps查看：
如果当前进程结束了，这个PID可以被可以被重复使用，但是所有“活着”的进程，它们的进程ID一定都是唯一的。
因为ID的唯一性，当我们想创建一个名字唯一的文件时，往往可以在文件名中加入PID，这样就能保证文件名的唯一性。
1.3.2 那么PID放在了那里呢？
进程在运行的过程中，OS会去管理进程，这就涉及到很多的管理信息，OS(Linux)为了管理进程，会为每一个进程创建一个
task_struct结构体变量，里面放了各种的该进程的管理信息，比如第一章介绍的文件描述符表，又比如我们这里讲的PID。
所以PID放在了该进程的task_struct结构体变量中，有关task_struct在前面的课程就介绍过，相信大家不会陌生。
1.3.3 如何获取PID呢？
后面回答这个问题。
1.4 三个特殊的进程
OS运行起来后有三个特殊的进程我们需要了解下，他们的PID分别是0、1、2。
0、1、2这个三个进程，是OS启动起来后会一直默默运行的进程，直到关机OS结束运行，尽管我们总是忽略它们的存在，但是它们
确非常的重要。
1.4.1 进程 PID == 0 的进程
（1）作用
这个进程被称为调度进程，功能是实现进程间的调度和切换，该进程根据调度算法，该进程会让CPU轮换的执行所有的进程。
怎么实现的？
当pc指向不同的进程时，cpu就去执行不同的进程，这样就能实现切换。
（2）这个进程怎么来的
这个进程就是有OS演变来的，OS启动起来后，最后有一部分代码会持续的运行，这个就是PID==0的进程。
由于这个进程是OS的一部分，凡是由OS代码演变来的进程，都称之为系统进程。
1.4.2 进程ID == 1的进程
（1）作用
1）作用1：初始化
这个进程被称为init进程，这个进程的作用是，他会去读取各种各样的系统文件，使用文件中的数据来初始化OS的启动，
让我们的OS进入多用户状态，也就是让OS支持多用户的登录。
2）作用2：托管孤儿进程
什么事孤儿进程，怎么托管的，有关这个问题后面会详细介绍。
3）作用3：原始父进程
原始进程————>进程————————>进程————————>终端进程——————>a.out进程
| | |
| | |
V V |
进程 进程 进程
| | |
| | |
... ... ...
（2）这个进程怎么运行起来的
这个进程不是OS演变来的，也就是说这个进程的代码不属于OS的代码，这个进程是一个独立的程序，程序代码放在了
/sbin/init下，当OS启动起来后，OS回去执行init程序，将它的代码加载到内存，这个进程就运行起来了。
1.4.3 进程ID == 2的进程
（1）作用
页精灵进程，专门负责虚拟内存的请页操作。
疑问：什么精灵进程？
精灵进程也叫守护进程，我们后面讲到“守护进程”这一章时，你自然就知道了。
怎么理解换页操作，我们说当OS支持虚拟内存机制时，加载应用程序到内存时，并不会进行完整的代码拷贝，只会拷贝当前要运
行的那部分代码，当这部分代码运行完毕后，会再拷贝另一部分需要运行的代码到内存中，拷贝时是按照一页一页来操作的，
每一页大概4096字节，这就是换页操作。
想了解详细换页操作的同学，请看《计算机体系结构》软件篇4——操作系统部分的课程。
（2）这个进程怎么运行起来的
与调度进程一样，也是一个系统进程，代码属于OS的一部分。
1.5 获取与进程相关的各种ID的函数
1.5.1 函数原型和所需头文件
#include <sys/types.h>
#include <unistd.h>
pid_t getpid(void);
pid_t getppid(void);
uid_t getuid(void);
gid_t getgid(void);
（1）功能
1）getpid函数：获取调用该函数进程的进程ID。
2）getppid函数：获取调用该函数进程的父进程ID，第一个P是parent，第二个process。
3）getuid函数：获取调用该函数进程的用户ID。
在什么用户下运行的该进程，得到的就是该用户的用户ID，查看/etc/passed文件，可以找到该UID对应的用户名。
4）getgid函数：获取用户组的ID，也就是调用该函数的那个进程，它的用户所在用户组的组ID。
（2）返回值：返回各种ID值，不会调用失败，永远都是成功的。
1.5.2 代码演示
2. 程序的运行过程
2.1 程序如何运行起来的
（1）在内存中划出一片内存空间
（2）将硬盘上可执行文件中的代码（机器指令）拷贝到划出的内存空间中
（3）pc指向第一条指令，cpu取指运行
当有OS时，以上过程肯定都是通过调用相应的API来实现的。
在Linux下，OS提供两个非常关键的API，一个是fork，另一个是exec。
fork：开辟出一块内存空间
exec：将程序代码（机器指令）拷贝到开辟的内存空间中，并让pc指向第一条指令，CPU开始执行，进程就运行起来了
运行起来的进程会与其它的进程切换着并发运行。
2.2 fork
2.2.1 函数原型
#include <unistd.h>
pid_t fork(void);
为了便于大家更容易的理解，我们在介绍fork时会适当的隐去一些信息，所以虽然不能保证100%是正确的，但是我们能够向
大家解释清楚fork函数的作用。
（1）函数功能
从调用该函数的进程复制出子进程，被复制的进程则被称为父进程，复制出来的进程称为子进程。
复制后有两个结果：
1）依照父进程内存空间样子，原样复制地开辟出子进程的内存空间
2）由于子进程的空间是原样复制的父进程空间，因此子进程内存空间中的代码和数据和父进程完全相同
其实复制父进程的主要目的，就是为了复制出一块内存空间，只不过复制的附带效果是，子进程原样的拷贝了一份
父进程的代码和数据，事实上复制出子进程内存空间的主要目的，其实是为了exec加载新程序的代码。
（2）函数参数：无参数。
（3）函数返回值
由于子进程原样复制了父进程的代码，因此父子进程都会执行fork函数，当然这个说法有些欠妥，但是暂且这么理解。
1）父进程的fork，成功返回子进程的PID，失败返回-1，errno被设置。
2）子进程的fork，成功返回0，失败返回-1，errno被设置。
（4） 代码演示
如何让父子进程做不同的事情？
2.2.2 说说复制的原理
Linux有虚拟内存机制，所以父进程是运行在虚拟内存上的，虚拟内存是OS通过数据结构基于物理内存模拟出来的，因此底层的
对应的还是物理内存。
复制时子进程时，会复制父进程的虚拟内存数据结构，那么就得到了子进程的虚拟内存，相应的底层会对应着一片新的物理内存
空间，里面放了与父进程一模一样代码和数据，
图：
如果想了解什么是虚拟内存，请看《计算机体系结构》软件篇4——操作系统。
2.2.3 父子进程各自会执行哪些代码
复制出子进程后，父子进程各自都有一份相同的代码，而且子进程也会被运行起来，那么我们来看一下，父子进程各自会执行
哪些代码。
图：
代码验证：
（1）父进程
1）执行fork前的代码
2）执行fork函数
父进程执行fork函数时，调用成功会返回值为子进程的PID，进入if(ret > 0){}中，执行里面的代码。
if(ret > 0){}中的代码只有父进程才会执行。
3）执行fork函数后的代码
（2）子进程
1）fork前的代码
尽管子进程复制了这段代码，但是子进程并不会执行，子进程只从fork开始执行。
2）子进程调用fork时，返回值为0，注意0不是PID。
进入if(ret == 0){}，执行里面的代码。
if(ret == 0){}中的代码只有子进程执行。
3）执行fork后的代码
（3）验证子进程复制了父进程的代码和数据
演示：
2.3 父子进程共享操作文件
（1）情况1：独立打开文件
多个进程独立打开同一文件实现共享操作，我们在第1章讲过，不过那时涉及到的多个进程是不相干进程，而现在我们这里要讲
的例子，里面所涉及到的两个进程是父子关系，不过情况是一样的。
1）代码演示
2）文件表结构
图；
独立打开同一文件时，父子进程各自的文件描述符，指向的是不同的文件表。
因为拥有不同的文件表，所以他们拥有各自独立的文件读写位置，会出现相互覆盖情况，如果不想相互覆盖，
需要加O_APPEND标志。
（2）情况2：fork之前打开文件
1）代码演示
2）文件表结构
图：
子进程会继承父进程已经打开的文件描述符，如果父进程的3描述符指向了某个文件，子进程所继承的文件描述符3也会指向这个文件。
像这种继承的情况，父子进程这两个相同的“文件描述符”指向的是相同的“文件表”。
由于共享的是相同的文件表，所以拥有共同的文件读写位置，不会出现覆盖的情况。
子进程的0 1 2这三个打开的文件描述符，其实也是从父进程那里继承过来的，并不是子进程自己去打开的，同样的父进程的
0 1 2又是从它的父进程那里继承过来的，最根溯源的话，都是从最原始的进程哪里继承过来的，我们前面介绍过，最原始的进
程是init进程。
init进程会去打开标准输入，标注输出、标准出错输出这三个文件，然后0 1 2分别指向打开的文件，之后所有进程的0 1 2，
实际上都是从最开始的init进程那里继承而来的。
init 012 012 012 012 012 012
原始进程————>进程————————>进程———>...———>终端进程——————>a.out进程——————>a.out进程
| | |
| | |
V V V
进程012 进程012 进程012
| | |
| | |
... ... ...
2.4 子进程会继承父进程的哪些属性
2.4.1 子进程继承如下性质
（1）用户ID，用户组ID
（2）进程组ID（下一篇讲）
（3）会话期ID（下一篇讲）
（4）控制终端（下一篇讲）
（5）当前工作目录
（6）根目录
（7）文件创建方式屏蔽字
（8）环境变量
（9）打开的文件描述符
等等
2.4.2 子进程独立的属性
（1）进程ID。
（2）不同的父进程ID。
（3）父进程设置的锁，子进程不能被继承。
等等
3. exec加载器
exec加载器就是我们之前介绍的加载函数。
3.1 exec的作用
父进程fork复制出子进程的内存空间后，子进程内存空间的代码和数据和父进程是相同的，这样没有太大的意义，我们需要在子进
程空间里面运行全新的代码，这样才有意义。
怎么运行新代码？
我们可以在if(ret==0){}里面直接写新代码，但是这样子很麻烦，如果新代码有上万行甚至更多的话，这种做法显然是不行的，因此
就有了exec加载器。
有了exec后，我们可以单独的另写一个程序，将其编译好后，使用exec来加载即可。
3.2 exec函数族
exec的函数有很多个，它们分别是execve、execl、execv、execle、execlp、execvp，都是加载函数。
其中execve是系统函数，其它的execl、execv、execle、execlp、execvp都是基于execve封装得到的库函数，因此我们这里重点介绍
execve函数，这个函数懂了，其它的函数原理是一样的。
3.2.1 execve函数原型
#include <unistd.h>
int execve(const char *filename, char **const argv, char **const envp);
（1）功能：向子进程空间加载新程序代码（编译后的机器指令）。
（2）参数：
1）filename：新程序（可执行文件）所在的路径名
可以是任何编译型语言所写的程序，比如可以是c、c++、汇编等，这些语言所写的程序被编译为机器指令后，
都可以被execve这函数加载执行。
正是由于这一点特性，我们才能够在C语言所实现的OS上，运行任何一种编译型语言所编写的程序。
疑问：java可以吗？
java属于解释性语言，它所写的程序被编译后只是字节码，并不是能被CPU直接执行的机器指令，所以不能被execve直接加
载执行，而是被虚拟机解释执行。
execve需要先加载运行java虚拟机程序，然后再由虚拟机程序去将字节码解释为机器指令，再有cpu去执行，在后面还会详细
讨论这个问题。
2）argv：传给main函数的参数，比如我可以将命令行参数传过去
3）envp：环境变量表
（3）返回值：函数调用成功不返回，失败则返回-1，且errno被设置。
（4）代码演示
命令行参数/环境表 命令行参数/环境表 命令行参数/环境表
终端窗口进程——————————————————>a.out（父进程）——————————————————————>a.out（子进程）——————————————>新程序
fork exec
exec的作用：将新程序代码加载（拷贝）到子进程的内存空间，替换掉原有的与父进程一模一样的代码和数据，让子进程空间运行全
新的程序。
3.3 在命令行执行./a.out，程序是如何运行起来的
（1）窗口进程先fork出子进程空间
（2）调用exec函数加载./a.out程序，并把命令行参数和环境变量表传递给新程序的main函数的形参
3.4 双击快捷图标，程序是怎么运行起来的
（1）图形界面进程fork出子进程空间
（2）调用exec函数，加载快捷图标所指向程序的代码
以图形界面方式运行时，就没有命令行参数了，但是会传递环境变量表。
4. system函数
如果我们需要创建一个进子进程，让子进程运行另一个程序的话，可以自己fork、execve来实现，但是这样的操作很麻烦，
所以就有了system这个库函数，这函数封装了fork和execve函数，调用时会自动的创建子进程空间，并把新程序的代码加载到
子进程空间中，然后运行起来。
虽然有system这函数，但是我们还是单独的介绍了fork和execve函数，因为希望通过这两个函数的介绍，让大家理解当有OS支持时，
程序时如何运行起来的。
4.1 system函数原型
#include <stdlib.h>
int system(const char *command);
（1）功能：创建子进程，并加载新程序到子进程空间，运行起来。
（2）参数：新程序的路径名
（3）代码演示
system（“ls”）;
system（“ls -al”）;
5. 回收进程资源
进程运行终止后，不管进程是正常终止还是异常终止的，必须回收进程所占用的资源。
5.1 为什么要回收进程的资源？
（1）程序代码在内存中动态运行起来后，才有了进程，进程既然结束了，就需要将代码占用的内存空间让出来（释放）。
（2）OS为了管理进程，为每个进程在内存中开辟了一个task_stuct结构体变量，进程结束了，那么这个结构体所占用的内存空间也
需要被释放。
（3）等其它资源
5.2 由谁来回收进程资源
由父进程来回收，父进程运行结束时，会负责释放子进程资源。
5.3 僵尸进程和孤儿进程
5.3.1 僵尸进程
子进程终止了，但是父进程还活着，父进程在没有回收子进程资源之前，子进程就是僵尸进程。
为什么子进程会变成僵尸进程？
子进程已经终止不再运行，但是父进程还在运行，它没有释放子进程占用的资源，所以就变成了占着资源不拉屎僵尸进程。
就好比人死后不腐烂，身体占用的资源得不到回收是一样的，像这种情况就是所谓的僵尸。
5.3.2 孤儿进程
没爹没妈的孩子就是孤儿，子进程活着，但是父进程终止了，子进程就是孤儿进程。
为了能够回收孤进程终止后的资源，孤儿进程会被托管给我们前面介绍的pid==1的init进程，每当被托管的子进程终止时，init会立即
主动回收孤儿进程资源，回收资源的速度很快，所以孤儿进程没有变成僵尸进程的机会。
5.3.3 演示
（1）僵尸进程
ps查看到的进程状态
R 正在运行
S 处于休眠状态
Z 僵尸进程，进程运行完了，等待被回收资源。
（2）孤儿进程
佳嵌工作室
标签：多个 计算机体系 快捷图标 内存数据 信息 字节码 僵尸 目的 路径名
原文地址：https://www.cnblogs.com/lemaden/p/10422354.html
