傻孢子都会的linux进程控制，你确定不会？

linux服务端的网络并发，详细解读网络io与线程进程关系

1.进程控制

1.1程序地址空间

这里的一些概念可能会颠覆你之前的认知，耐下心慢慢看哈！

空间布局图：

代码段：存放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;
}

结果如下

超详细总结linux进程控制，你确定不进来看看？
我们发现父子进程里面的变量的值和地址是完全一样的，这很好理解，因为子进程是按照父进程为模板，子进程并没有对变量进行任何操作，然后我们将代码稍微改动一下：

#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进程控制，你确定不进来看看？
原理如下图所示：

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

结论

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

超详细总结linux进程控制，你确定不进来看看？

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

1、分页式

页号+页内偏移量

页：512字节~8kb，通常都是4096字节（4k）

页号=虚拟地址/页的大小

页内偏移=虚拟地址%页的大小

超详细总结linux进程控制，你确定不进来看看？
2、分段式

段号+段内偏移量

超详细总结linux进程控制，你确定不进来看看？
3、段页式 段号+页号+页内偏移量 将上面两个图结合起来就是，不需要了解太多哈，我就不画图了

1.3其他一些概念

1.进程间的运行时抢占式执行

使用fork创建出来的子进程，父子进程在执行各自代码的时候，也是抢占式执行的。

2.并行和并发

并行:多个进程同时拥有不同的CPU，进行运算，称之为并行

并发:多个进程在同一时刻只能有一个进程拥有CPU，进行运算，称之为并发

3.独立性:多进程运行，需要独享各种资源，多进程运行期间互不干扰

2.进程创建

2.1写时拷贝

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

3.进程终止

3.1进程终止的退出场景

代码运行完毕，结果正确
代码运行完毕，结果不正确
代码异常终止
通过 echo $? 查看进程退出码

常见的退出方法

main函数return退出
ctrl+c
kill -9 进程号/进程名
exit函数
_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

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

void myhome(void)
{
     printf("i want to go home\n");
 }
 
 int main()
 {
     atexit(myhome);                                                                         
     printf("hello world!\n");
     return 0;
 }

结果如下

超详细总结linux进程控制，你确定不进来看看？
原因是atexit函数是注册了一个函数myhome，注册并不是调用。当main函数结束之后，才会调用刚刚注册的myhome函数。

3.4刷新缓冲区的办法

main函数的return返回之后
fflush :强制刷新
\n
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比特位

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

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

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

1.bash的应用场景

2.守护进程

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

作用:保护业务进程

1.启动业务进程的时候，不是直接启动业务程序。而是启动守护进程

2.让守护进程，创建一个子进程，让子进程进程程序替换成为业务程序进程。

3.守护进程和业务进程进行进程通信，让守护进程得知业务进程的情况

业务进程正常，则守护进程不做处理

业务进程崩溃，或者异常，则守护进程重新拉起来一个子进程,让子进程在进行进程程序替换

文末福利，笔者花3个月整合了一套Kali渗透/网络安全/黑客/Linux/攻防/漏洞资料合集及工具包，现在免费分享给大家【点击获取】
以上就是本篇文章的重点，今天就到此结束了。