爆肝近万字总结----Linux进程控制系列文章，你确定不点进来看看？

Posted 2021-06-29 程序猿是小贺

铁子们，大家好啊，我是小贺，在之前的文章中我们学到了进程的一些基础概念以及环境变量的概念，那么今天我带大家一起走向我们今天的进程控制章节，各位小板凳坐好，我们要发车了。

1.进程控制

1.1程序地址空间

之前学过C/C++的铁子们注意一下，这里的一些概念可能会颠覆你之前的认知，耐下心慢慢看哈！

空间布局图：

代码段：存放CPU执行的机器指令（machine instructions）。通常代码区是可共享的（即其他的执行程序可以调用它），因为对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外地修改了它的指令。另外，代码区还规划了局部变量的相关信息。
数据段：存放已初始化全局变量，静态变量（包括全局静态变量和局部静态变量），和常量数据（例如常量字符串)。
未初始化数据区BSS:存入的是未初始化全局变量，未初始化静态变量，初始化为0的全局变量，初始化为0的静态变量。
堆区：用于动态内存分配，向上生长。
栈区：编译器自动分配和释放，存放局部变量，函数参数，返回数据等。向下生长。

到这里我先纠正一下，我们通常说的程序地址空间实际上就是程序虚拟地址空间。

程序虚拟地址空间与内存指针的关系：
内存指针指向了程序虚拟地址空间，如图所示

到这里我想大家应该不太明白，那我就来给大家举个例子。

1.首先定义一个全局变量g_val = 100
2.父进程创建一个子进程
3.打印父进程中全局变量的值和地址
打印子进程中全局变量的值和地址

#include <stdio.h>
#include <unistd.h>

int g_val = 100; //定义一个全局变量

int main()
{
    pid_t pid = fork();
    if(pid < 0)
    {
        perror("fork"); //标准错误
        return 0;
    }
    else if(pid == 0)
    {
        //子进程
        printf("我是子进程，g_val = %d , &g_val = %p\\n",g_val, &g_val);
    }
    else 
    {
        //父进程
        printf("我是父进程，g_val = %d , &g_val = %p\\n",g_val, &g_val);  
    }
    return 0;
}

结果如下

我们发现父子进程里面的变量的值和地址是完全一样的，这很好理解，因为子进程是按照父进程为模板，子进程并没有对变量进行任何操作，然后我们将代码稍微改动一下：

#include <stdio.h>
#include <unistd.h>

int g_val = 100; //定义一个全局变量

int main()
{
    pid_t pid = fork();
    if(pid < 0)
    {
        perror("fork"); //标准错误
        return 0;
    }
    else if(pid == 0)
    {
        //子进程
        printf("我是子进程，g_val = %d , &g_val = %p\\n",g_val, &g_val);
    }
    else 
    {
    	g_val = 0;
        //父进程
        printf("我是父进程，g_val = %d , &g_val = %p\\n",g_val, &g_val);  
    }
    return 0;
}

结果如下

原理如下图所示：

此时对比上下两个结果可以看出来，父子进程中的值发生了改变，但是他们的地址还是同一块地址，所以得出以下结论：

结论

• 变量内容不一样。所以父子进程输出的变量绝对不是同一个变量
• 地址是一样的，所以该地址一定不是物理地址
• 在Linux下，这种地址叫做虚拟地址
• 我们在c/c++语言所看到的地址，全都是虚拟地址，物理地址用户一概看不到，由OS统一管理
• OS负责将虚拟地址转化为物理地址

1.2将虚拟地址转化为物理地址

1. 分页式
   页号+页内偏移量
   页：512字节~8kb，通常都是4096字节（4k）
   页号=虚拟地址/页的大小
   页内偏移=虚拟地址%页的大小
   
2. 分段式
   段号+段内偏移量
   
3. 段页式
   段号+页号+页内偏移量
   将上面两个图结合起来就是，不需要了解太多哈，我就不画图了

1.3其他一些概念

1.进程间的运行时抢占式执行
使用fork创建出来的子进程，父子进程在执行各自代码的时候，也是抢占式执行的。
2.并行和并发
并行:多个进程同时拥有不同的CPU，进行运算，称之为并行
并发:多个进程在同一时刻只能有一个进程拥有CPU，进行运算，称之为并发
3.独立性:多进程运行，需要独享各种资源，多进程运行期间互不干扰

2.进程创建

2.1写时拷贝

父子进程代码共享，数据独有。
当任意一方试图写入，便以写时拷贝的方式拷贝一份副本，修改谁则谁指向副本（因为这里重新开辟了空间，为深拷贝）

3.进程终止

3.1进程终止的退出场景

• 代码运行完毕，结果正确
• 代码运行完毕，结果不正确
• 代码异常终止

通过 echo $? 查看进程退出码

常见的退出方法

1. main函数return退出
2. ctrl+c
3. kill -9 进程号/进程名
4. exit函数
5. _exit函数

3.2exit函数与_exit函数

exit函数
void exit(int status) 库函数
谁调用谁退出
status :进程退出的状态码
exit函数的内部封装了_exit函数。
exit函数在退出进程的时候要比_exit函数多干两件事情:
1.执行用户自定义的清理函数
2.刷新缓冲区
** _exit函数**
void _exit(int status) 系统调用函数
谁调用谁退出

3.3回调函数atexit简述

1.注册回调函数
2.调用回调函数
atexit函数
int atexit(void (*function) (void) ) ;
参数为函数指针类型，接收一个函数的地址，函数的返回值为void，参数也是void

  1 #include <stdio.h>
  2 #include <unistd.h>
  3 #include <stdlib.h>
  4 
  5 void myhome(void)
  6 {
  7     printf("i want to go home\\n");
  8 }
  9 
 10 int main()
 11 {
 12     atexit(myhome);                                                                         
 13     printf("hello world!\\n");
 14     return 0;
 15 }

你们会觉得先输出那条语句呢？
想想，再往下看

------------------------------ 我是分割线 -------------------------------
结果如下

原因是atexit函数是注册了一个函数myhome，注册并不是调用。当main函数结束之后，才会调用刚刚注册的myhome函数。

3.4刷新缓冲区的办法

1. main函数的return返回之后
2. fflush :强制刷新
3. \\n
4. exit函数

4.进程等待

作用
父进程调用进程等待的方法，等待子进程退出，防止子进程变成僵尸进程
方法

4.1wait函数

函数原型是

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

函数功能是：父进程一旦调用了wait就立即阻塞自己，由wait自动分析是否当前进程的某个子进程已经退出，如果让它找到了这样一个已经变成僵尸的子进程，wait就会收集这个子进程的信息，并把它彻底销毁后返回；如果没有找到这样一个子进程，wait就会一直阻塞在这里，直到有一个出现为止。
参数:
输出型参数:将wait函数内部计算的结果通过status返回给调用者
输入型参数:调用者给被调用函数的传参
输入输出型参数
status返回值
成功pid 失败 -1
status传出参数
阻塞等待子进程
回收子进程资源
获取子进程结束状态：
1）WIFEXITED（）真
WEXITSTATUS（）获取子进程退出状态
2）WIFSIGNALED（） 真
WTERMSIG（）获取导致子进程终止的信号的编码

只研究status低16比特位

wait函数，这里写的很全我就不献丑了哈！

4.2waitpid函数

作用同于wait，但可指定pid进程清理，可以不阻塞。

pid_t waitpid(pid_t pid,int *status,int options)

成功：返回清理掉的子进程PID；失败：-1（无子进程）

特殊参数和返回情况：
参数pid：
>0 回收指定ID的子进程
-1 回收任意子进程（相当于wait）
0 回收和当前调用waitpid一个组的所有子进程
< -1 回收指定进程组内的任意子进程
返回0：参数3为WNOHANG，且子进程正在运行。
注意：一次wait或waitpid调用只能清理一个子进程，清理多个子进程需要用到循环

5.进程程序替换

5.1进程程序替换原理

替换当前进程的代码段和数据段为新的程序，并且更新堆栈
注意:当进程程序替换完毕之后，进程就在执行新的程序，但是进程的进程号不变

5.2进程程序替换函数

exec函数簇

#include <unistd.h>
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[]);

path :待要替换的可执行程序，需要指定该程序在哪一个路径下
file :待要替换的可执行程序，可以不给路径（但是这个待要替换的可执行程序一定在PATH环境变量中可以搜索到)）。

arg :给可执行程序传递的命令行参数
argv[ ] :指针数组，保存的是给可执行程序传递的参数
注意:
数组的第一个元素应为可执行程序本身
数组的最后一个元素应该为NULL

envp[]:程序员自己组织环境变量，最后一个参数为NULL

返回值:
如果替换成功，则没有返回值;因为替换成功之后，就执行其他的程序了。
如果替换失败,则返回值为-1

后缀	含义
l	l代表list,接受以逗号的参数，最后是以(char *)0结束。
v	v代表vector,接受参数数组，数组以NULL结束。
p	p代表取用PATH环境环境寻找可执行文件，不需要单独传入一个路径参数。
e	取代当前的环境环境

前五个函数都是库函数，依赖于execve这个系统调用函数。

5.3进程程序替换函数应用场景

1.bash的应用场景

2.守护进程
守护进程(daemon)是一类在后台运行的特殊进程，用于执行特定的系统任务。很多守护进程在系统引导的时候启动，并且一直运行直到系统关闭。另一些只在需要的时候才启动，完成任务后就自动结束
作用:保护业务进程

1.启动业务进程的时候，不是直接启动业务程序。而是启动守护进程
2.让守护进程，创建一个子进程，让子进程进程程序替换成为业务程序进程。
3.守护进程和业务进程进行进程通信，让守护进程得知业务进程的情况
业务进程正常，则守护进程不做处理
业务进程崩溃，或者异常，则守护进程重新拉起来一个子进程,让子进程在进行进程程序替换

注明：转载请提示出处

以上就是本篇文章的重点，今天就到此结束了哈，有不同的观点或者有不同思路的朋友欢迎大家赏光私我哈，本着相互进步的原则，希望大家能多多向我提意见，谢谢~~