[Linux][进程控制][进程程序替换]详细解读

1.进程创建

1.fork函数初识

在Linux中fork函数是非常重要的函数，它从已存在进程中创建一个新进程
- 新进程为子进程，而原进程为父进程
进程调用fork，当控制转移到内核中的fork代码后，内核做：
- 分配新的内存块和内核数据结构给子进程
  - 必须子进程自己独有，因为进程具有独立性
- 将父进程部分数据结构内容拷贝至子进程
  - 代码：都是不可被写的，只能读取，所以父子共享，没有问题
  - 数据：可能被修改的，所以必须分离
- 添加子进程到系统进程列表当中
- fork返回，开始调度器调度
当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但每个进程都将可以开始它们自己的旅程

cpp 复制代码

int main(void)
{
    pid_t pid;
    printf("Before: pid is %d\n", getpid());

    if ((pid = fork()) == -1)
        perror("fork()"), exit(1);

    printf("After:pid is %d, fork return %d\n", getpid(), pid);
    sleep(1);
    
    return 0;
}

运行结果  
Before: pid is 43676
After:pid is 43676, fork return 43677
After:pid is 43677, fork return 0

进程43676先打印before消息，然后它有打印after。另一个after消息由43677打印的
- 注意到进程43677没有打印before，为什么呢？

所以，fork之前父进程独立执行，fork之后，父子两个执行流分别执行
- 注意：fork之后，谁先执行完全由调度器决定

2.fork函数返回值

父进程返回的是子进程的PID
子进程返回0

3.写时拷贝

通常，父子代码共享，父子在不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自获得一份副本
为什么要这样设计呢？为什么不可以在创建进程的时候，就直接拷贝分离父子进程呢？
- 可能拷贝子进程根本就不会用到数据空间，即便是用到了，也可能只是读取
- 创建子进程，不需要将不会被访问的数据或者只会被读取的数据拷贝一份
- 但是，还必须得拷贝数据，但什么样的数据值得拷贝呢？
  - 将来会被父/子进程写入的数据
- 但是，提前拷贝了，会立马使用吗？
  - 一般而言，即便是OS，也无法提前知道哪些空间可能会被写入
- 综上，OS选择了"写时拷贝 "技术，来进程将父子进程的数据分离
  - 因为有写时拷贝的存在，所以，父子进程得以彻底分离，完成了进程独立性的技术保证
OS为何要选择写时拷贝技术，对父子进程进行分离？
- 用的时候，再给你分配，是高效使用内存的一种表现
- OS无法在代码执行前预知哪些空间会被访问

4.fork之后，父子进程代码共享

共享的代码是after之后的代码，还是所有的代码都共享呢？
- 共享的是所有的代码
- 但是执行的是fork之后的代码

5.fork常规用法

一个父进程希望复制自己，使父子进程同时执行不同的代码段
- 例如：父进程等待客户端请求，生成子进程来处理请求
一个进程要执行一个不同的程序
- 例如：子进程从fork返回后，调用exec函数

6.fork调用失败的原因

系统中有太多的进程
实际用户的进程数超过了限制

2.进程终止

0.进程终止时，操作系统做了什么？

释放进程申请的相关内核数据结构和对应的数据和代码 --> 本质就是释放资源

1.进程退出场景

代码运行完毕，结果正确
代码运行完毕，结果不正确
代码没有跑完，程序崩溃了
main函数的返回值的意义是什么？return 0的含义是什么？为什么总是0？
- 返回给上一级进程，用来评判该进程执行结果用的，可以忽略
- 此处的0为进程的**退出码，**并不总是0
  - 0：success 非0：标识的时运行的结果不正确
  - 非零值有无数个，不同的非零值就可以标识不同的错误原因
  - 给我们的程序在运行结束之后，结果不正确时，方便定位错误的原因细节
  - 程序崩溃的时候，退出码无意义 -- 一般而言退出码对应的return语句没有被执行

2.进程常见退出方法

可以通过**echo $?**查看进程退出码
正常终止：
- 从main函数，return 退出码
  - return语句就是终止进程的
  - return n等同于执行exit(n)
- 调用exit
  - exit在代码的任何地方调用，都表示直接终止进程
- _exit
异常退出：
- Ctrl + c，信号终止

4 _exit函数(系统接口)

cpp 复制代码

void _exit(int status);

参数：status 定义了进程的终止状态，父进程通过wait来获取该值
- **说明：虽然status是int，但是仅有低8位可以被父进程所用。所以_exit(-1)时，在终端执行$?**发现返回值是255

4.exit函数(库函数)

cpp 复制代码

void exit(int status);

exit 最后也会调用**_exit**(库函数封装系统接口)**，**但在调用之前，还做了其他工作：
1. 执行用户通过atexit 或on_exit定义的清理函数
2. 关闭所有打开的流，所有的缓存数据均被写入
3. 调用_exit

cpp 复制代码

int main()
{
    printf("hello");
    exit(0);
}

// 运行结果：hello

cpp 复制代码

int main()
{
    printf("hello");
    _exit(0);
}

// 运行结果：(空)

3.进程等待

1.进程等待必要性

子进程退出，父进程若不管不顾，就可能造成"僵尸进程"的问题，进而造成内存泄漏
另外，进程一旦变成僵尸状态，那就刀枪不入，"杀人不眨眼"的kill -9 也无能为力
因为谁也没有办法杀死一个已经死去的进程
最后，父进程派给子进程的任务完成的如何，我们需要知道
如：子进程运行完成，结果对还是不对，或者是否正常退出
父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

2.进程等待的方法

wait： pid_t wait(int *status);
- 返回值：成功返回被等待进程pid，失败返回-1
- 参数：输出型参数，获取子进程退出状态，不关心则可以设置成为NULL
waitpid： pid_t waitpid(pid_t pid, int *status, int options);
- 返回值：
  - 收集到的子进程的进程ID
    - 等待成功&&子进程退出
  - 如果设置了选项WNOHANG，而调用中waitpid发现没有已退出的子进程可收集，则返回0
    - 等待成功&&子进程未退出
  - 如果调用中出错,则返回**-1**
- 参数：
  - pid：
    - Pid=-1，等待任一个子进程 --> 与wait等效
    - Pid>0，等待其进程ID与pid相等的子进程
  - status:
    - WIFEXITED(status) ：若为正常终止子进程返回的状态，则为真（查看进程是否是正常退出）
    - WEXITSTATUS(status) ：若WIFEXITED非零，提取子进程退出码（查看进程的退出码）
  - options：
    - WNOHANG ：让父进程非阻塞等待
      - 若pid指定的子进程没有结束，则waitpid()函数返回0
    - 默认为0，表示阻塞等待
注意：
- 如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息
- 如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞
- 如果不存在该子进程，则立即出错返回

3.获取子进程status

wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充
- 如果传递NULL，表示不关心子进程的退出状态信息
- 否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程
status****不能简单的当作整形来看待，可以当作位图来看待（只研究status低16比特位）
- 次低8位，表示子进程退出的退出码
- 最低7位，表示进程收到的信号
- 第8位，core dump标志
由此，可知：
- 进程异常退出或者崩溃，本质是操作系统杀掉了进程
- 操作系统如何杀掉进程的呢？
  - 本质是通过发送信号的方式
- 程序异常，不光光是内部代码有问题，也可能是外力直接杀掉
  - 子进程跑完了吗？ --> 不能确定

4.思考问题

父进程为什么要用wait/waitpid函数拿子进程的退出结果？直接全局变量不行吗？
- 进程具有独立性，数据会进行写时拷贝，父进程无法拿到子进程修改过的数据
- 并且，信号无法通过全局变量拿到
既然进程是具有独立性的，进程退出码也是子进程的数据，父进程为什么能拿到？wait/waitpid究竟干了什么？
- 僵尸进程：至少要保留该进程的PCB信息
  - task_struct里面保留了任何进程退出时的退出结果信息
- 本质就是读取子进程的task_struct结构
- wait/wait有权利拿task_struct里面的数据么？task_struct是内核数据结构对象
  - wait/waitpid是系统调用，操作系统当然可以访问内核数据

4.进程程序替换

0.为什么要创建一个新的子进程？

为了不影响父进程
想让父进程聚焦在读取数据，解析数据，指派进程执行代码的功能
如果不创建，那么替换的进程只能是父进程，如果创建了，替换的进程就是子进程，而不影响父进程

1.替换原理

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支)
- 但如果子进程想执行一个全新的程序，该怎么办？
子进程往往要调用一种exec函数以执行另一个程序
- 当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行
  - 将新的磁盘上的程序加载到内存，并和当前进程的页表，重新建立映射
- 调用exec并不创建新进程，所以调用exec前后该进程的id并未改变

2.替换函数

有六种以exec开头的函数，统称exec函数
- exec*：功能其实就是加载器的底层接口

cpp 复制代码

int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ..., char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);

可变参数列表部分/环境变量，最后一个参数必须是NULL，标识参数传递完毕
这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回
- 如果调用出错则返回-1
- 所以exec函数只有出错的返回值而没有成功的返回值
命名理解：
- l(list) : 表示参数采用列表
- v(vector) : 参数用数组
- p(path) : 有p自动搜索环境变量PATH
  - 在环境变量PATH中查找要执行的程序
- e(env) : 表示自己维护环境变量
注意:传参时，第一个参数都应该和要替换的程序名一样

函数名	参数格式	是否带路径	是否使用当前环境变量
execl	列表	不是	是
execlp	列表	是	是
execle	列表	不是	不是，须自己配置环境变量
execv	数组	不是	是
execvp	数组	是	是
execve	数组	不是	不是，须自己配置环境变量

事实上，只有execve是真正的系统调用，其它五个函数最终都调用execve

3.思考问题

加载新程序之前，父子的数据和和代码的关系 --> 代码共享，数据写时拷贝
- 当子进程加载新程序的时候，不就是一种"写入"么，代码要不要写时拷贝，将父子的代码分离？
  - 必须分离
  - 父子进程在代码和数据上就彻底分开了

[Linux][进程控制][进程程序替换]详细解读

目录

1.进程创建

1.fork函数初识

2.fork函数返回值

3.写时拷贝

4.fork之后，父子进程代码共享

5.fork常规用法

6.fork调用失败的原因

2.进程终止

0.进程终止时，操作系统做了什么？

1.进程退出场景

2.进程常见退出方法

4 _exit函数(系统接口)

4.exit函数(库函数)

3.进程等待

1.进程等待必要性

2.进程等待的方法

3.获取子进程status

4.思考问题

4.进程程序替换

0.为什么要创建一个新的子进程？

1.替换原理

2.替换函数

3.思考问题