Linux篇：进程

一、进程概念:
1、已经加载到内存中的程序/正在运行的程序叫做进程，一个操作系统不仅仅只能运行一个进程，可以同时运行多个进程。
2、操作系统，必须将进程管理起来，而管理的过程是先描述，再组织。
3、任何一个进程，在加载到内存的时候，形成真正的进程时，操作系统要先创建描述进程（属性）的结构体对象PCB（process control block）---进程控制块（进程属性的集合）。
4、此结构体包括进程编号，进程的状态，优先级，代码和数据相关的指针信息等。
5、根据进程的PCB类型，该进程创建对应的PCB对象。有了PCB结构体对象，在操作系统中对进程进行管理，变成了对单链表进行增删改查。
6、进程=内核数据结构（PCB）+代码和数据。
7、在linux中描述进程的结构体叫做task_struct，最基本的组织进程task struct方式采用双向链表组织的，里面包含进程的所有属性。

二、Linux中有关进程的指令

ps查看进程：

ls /proc：显示系统中动态运行的所有进程的信息：

cwd：自身所在当前linux的绝对路径：

getpid（）获取进程pid，getppid（）获取进程ppid：

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

int main()
{
        while(1)
        {
                printf("我的pid是%d，我的ppid是%d\n",getpid(),getppid());
                sleep(1);
        }
        return 0;
}

三、父进程与子进程

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>

int main()
{
        pid_t id = fork();
        if(id == 0)
        {
                //子进程
                while(1)
                {
                        printf("我是子进程，pid:%d,ppid:%d\n",getpid(),getppid());
                        sleep(1);
                }
        }
        else if(id > 0)
        {
                //父进程
                while(1)
                {
                        printf("我是父进程，pid:%d,ppid:%d\n",getpid(),getppid());
                        sleep(1);
                }
        }
        else
        {
                //error
        }

        return 0;
}

1、parent进程含义：
我们登录xshell时，系统会为我们创建一个bash进程，即命令行解释的进程，帮我们在显示器中打印对话框终端。
我们在对话框中输入的所有的指令都是bash进程的子进程。
bash进程只进行命令行解释，具体执行出错只会影响他的子进程。
进程PID会变化，而它的ppid一般在同一个终端下启动，它都是不变的，而它的所有的进程的父进程都是bash。
2、fork：创建子进程：
创建子进程PCB，填充PCB对应的内容，让子进程和父进程指向相同的代码，父子进程都是有独立的task struct，可以被CPU调度运行了。

3、不同方法创建子进程
①./运行程序---指令级别创建子进程
②fork（）---代码层面创建子进程

4、为什么fork要给子进程返回零，给父进程返回子进程PID？
fork给父进程返回子进程pid，用来标定子进程的唯一性。而子进程只要调用getpid（）就可获取进程的PID。返回不同的返回值，是为了区分，让不同的执行流，执行不同的代码快。（一般而言，fork之后的代码父子共享）

5、一个函数是如何做到返回两次的？一个变量怎么会有不同的内容？如何理解？
任何平台，进程在运行的时候是具有独立性的。代码共享并不影响独立性，因为代码不可修改。而数据上互相独立，子进程理论上要拷贝父进程数据。但创建出来的子进程，对于大部分父进程不会访问，所以子进程在访问父进程数据时进行写时拷贝即可（子进程和父进程访问的是不同的内存区）。

6、谁决定把一个进程放到CPU上去运行呢？是由调度器（CPU）去决定的。
如果父子进程被创建好fork（）往后谁先进行呢？谁先进行由调度器决定，不确定。

四、进程的状态：

1、进程的状态：

①R运行状态: 表明进程是在运行中或者在运行队列里。
②S睡眠状态: 意味着进程在等待事件完成。
③D磁盘休眠状态：让进程在磁盘写入完毕期间，这个进程不能被任何人杀掉。
④T停止状态： 可以通过发送 SIGSTOP（kill -19） 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号（kill -18）让进程继续运行。
⑤X死亡状态：操作系统将该进程的数据全部释放掉。
⑥Z僵尸进程：进程一般退出的时候，如果父进程，没有主动回收子进程信息，子进程会一直让自己出于Z状态，进程的相关资源尤其是task_struct结构体不能被释放。

2、进程切换：每一个进程都有一个叫做时间片的概念。大量的把进程从CPU上放上去，拿下来的动作叫做进程切换。
运行：（该数据出处于运行队列）
阻塞：正在执行的进程由于发生某时间暂时无法继续执行。此时引起进程调度，OS把处理机分配给另一个就绪进程，而让受阻进程处于暂停状态，一般将这种状态称为阻塞状态。（该数据处于等待队列）
挂起：由于系统和用户的需要引入了挂起的操作，进程被挂起意味着该进程处于静止状态。如果进程正在执行，它将暂停执行，若原本处于就绪状态，则该进程此时暂不接受调度。

3、进程一般退出的时候，如果父进程没有主动回收子进程信息，子进程会一直让自己处于z状态，进程的相关资源，尤其是task struct结构体不能被释放
父子进程，父进程先退出，子进程的父进程会被改写成1号进程（init或systemd）。
父进程是1号进程--孤儿进程，该进程会被系统领养。

五、进程优先级

PRI（priority）：优先级
NI（nice）：进程优先级的修正数据
PRI（new）=PRI（old）+nice（old每次都默认从80开始）
top：调整优先级
r（renice）：先输入pid，后输入调整的nice值。

基于进程切换，基于时间片轮转的调度算法：进程切换+双队列+时间片

六、进程切换：

1、什么函数返回值会被外部拿到呢？
通过CPU寄存器：return a->mov eax 10

2、系统如何得知我们的进程当前执行到哪行代码了？
程序计数器pc，eip：记录当前进程正在执行指令的下一行指令的地址。

3、寄存器：提高效率，进程高频数据放入寄存器中。CPU内的寄存器里面保存的是进程相关的临时数据--进程的上下文，随时随地可能被CPU访问读取修改。
通用寄存器：eax,ebx,ecx,edx
栈帧：ebp,esp,eip
状态寄存器：status

4、进程在CPU上离开的时候，要将自己的上下文数据保存好，甚至带走。保存的目的，未来都是为了恢复。进程在被切换的时候，保存上下文， 恢复上下文。

七、环境变量：

1、系统中，针对于指令的搜索，Linux会为我们提供一个环境变量PATH（Linux的指令搜索路径）。

echo $PATH      --查看当前环境变量
PATH=$PATH:路径    --将该路径添加到环境变量
PATH=路径    --将该路径覆盖写入环境变量

其他的环境变量：

2、环境变量是系统提供的一组name=value形式的变量，不同的环境变量有不同的用户，通常具有全局属性。

env：显示当前自己的进程，以及bash进程，从系统中继承下来的，所有环境变量

HISTSIZE：历史命令被记录下来的条数
USER：当前账户
HOMR：当前路径家目录
PWD：当前进程处于哪一路径下。
OLDPWD：当前路径的上一路径
LOGNAME：当前登录用户

history：查看到历史所有的指令
getenv（）：C/C++获取环境变量的方式

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

int main()
{
        char who[32];
        strcpy(who,getenv("USER"));
        if(strcmp(who, "root") == 0)
        {
                printf("让他做任何事情"）:
        }
        else
        {
                printf("你就是个普通用户，受权限约束");
        }
        return 0;
}

3、命令行参数:int main（int argc，char*argv[],  char*env[]）
 ①指令的解析：命令行参数以空格作为分隔符，将字符串打散成几个元素，分别传递给main函数。为指令、工具、软件等提供命令行选项的支持。

#include <stdio.h>
int main(int argc, char* argv[], char* env[])
{
    int i = 0;
    for (; env[i]; i++) {
        printf("%s\n", env[i]);
    }
    return 0;
}

两张核心参数表：命令行参数表，环境变量表（环境变量对应的组织方式是以指针数组char*[]的形式把环境变量依次以字符串的形式在当前进程的上下文中组织的）

②我们所运行的进程都是子进程，bash本身在启动的时候会从操作系统的配置文件中读取环境变量信息，子进程会继承父进程交给我们的环境变量。

③本地变量：不会被子进程继承，只会在bash内部有效。
export导入环境变量
unset取消环境变量
set：查到系统当中所有的变量（包括本地变量和环境变量）

④命令行上的指令不一定全部都要创建子进程。
两批命令：
a.常规命令：通过创建子进程完成的。
b.内建命令：bash不创建子进程，而是由自己亲自执行，类似于bash调用了自己写的，或者系统提供的函数。

⑤获取环境变量的两个方法：
a.通过参数的方式获取
b.编译时是该指针指向父进程的环境变量表数据

int main()
{
    extern char** environ;
    int i = 0;
    for (; environ[i]; i++)
    {
        printf("%d: %s\n", i, environ[i]);
    }
}

八、进程地址空间

1、程序地址空间分布情况：

//myproc.c

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

int g_val_1;
int g_val_2 = 100;

int main()
{
        printf("code addr: %p/n", main);
        const char *str = "hello bit";
        printf("read only string addr: %p\n", str);
        printf("init global value addr: %p\n", &g_val_2);
        printf("uninit global value addr: %p\n", &g_val_1);
        char *mem = (char*)malloc(100);
        printf("heap addr: %p\n", mem);
        printf("stack addr: %p\n", &str);

        return 0;
}

注：static修饰的局部变量，编译的时候已经被编译到全局数据区。

2、地址空间

先做一个小实验：

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

int g_val = 100;

int main()
{
    pid_t id = fork();
    if (id == 0)
    {
        int cnt = 5;
        //子进程
        while (1)
        {
            printf("I am child, pid : %d, ppid : %d, g_val: %d, &g_val: %p\n", getpid(), getppid(), g_val, &g_val);
            sleep(1);
            if (cnt) cnt--;
            else
            {
                g_val = 200;
                printf("子进程change g_val : 100->200\n");
                cnt--;
            }
        }
    }
    else
    {
        //父进程
        while (1)
        {
            printf("I am parent, pid : %d, ppid : %d, g_val: %d, &g_val: %p\n", getpid(), getppid(), g_val, &g_val);
            sleep(1);
        }
    }
}

问1：怎么可能同一个变量，同一个地址，同时读取，读到了不同的内容结论？
答：
①如果变量的地址是物理地址，不可能存在上面的现象，绝对不是物理地址，是线性地址/虚拟地址。
②子进程的进程地址空间继承自父进程，但是当实际访问读取时，需要根据相同的虚拟地址（映射）查找不同的物理地址。
③修改子进程变量时，先经过写时拷贝（是由操作系统自动完成的）并重新开辟空间，但是在这个过程中，不会影响虚拟地址。

拓展：在32位计算机中，有32位的地址和数据总线
每一根地址总线只有0、1（32根，2^32种）
（三类线：地址总线，数据总线控制，总线
CPU和内存中连的线叫系统总线
内存和外设中连的线叫IO总线）

问2：什么叫做地址空间？如何理解？
答：
①进程在极端情况下所能访问的物理内存的最大值。地址，总线，排列组合形成地址范围［0，2^32］。
②通过定义一个区域的起始和结束来实现地址空间上的区域划分。
③所谓的进程地址空间，本质上是一个描述进程可视范围的大小
地址空间内一定要存在各种区域划分，对线性地址进行start和end即可
在范围内，连续空间中，每一个最小单位都可以有地址，这个地址可以被对象直接使用。

问3：地址空间本质是内核的一个数据结构对象，类似PCB一样，地址空间也是要被操作系统管理的：先描述，再组织 。这样做的目的是什么？
答：
①让进程以统一的视角看待内存，进程就不需要再维护自己冗余的代码
②增加进程虚拟地址空间可以让我们访问内存的时候，增加一个转换的过程，在这个转化的过程中，可以对寻址记请求进行审查，所以一旦异常访问，直接拦截，该请求不会到达内存，保护物理内存。

3、页表

①每个当前正在执行的进程的页表，在CPU内有一个cr3寄存器，保存当前页表的起始地址（这是物理地址）。该进程在运行期间cr3寄存器中页表的地址/当前进程正在运行的临时数据，本质上属于进程的硬件上下文。

②代码区和字符常量区所匹配的页表所对应的虚拟物理地址映射标志位决定是否只读。（代码是只读的，字符常量区只读的）

③操作系统对大文件可以实现分批加载，惰性加载的方式。另外有一个标志位标识对你的代码和数据是否已经被加载到内存。

④如果发现当前代码和数据并未加载到内存里，此时，操作系统触发缺页中断。将未加载到内存中的代码和数据，重新加载到内存里，把这段内存的地址填写到对应的页表当中，再访问。

注：写时拷贝也是缺页中断：一旦创建子进程，可读的内容不变，可写的内容对应的虚拟内存以及操作系统会把父进程对应的可写区域内容全部改成只读，从而子进程继承下来也为只读。一旦父进程或子进程尝试对数据段进行写入时，会通过触发读权限问题进行写时拷贝。

问：进程在被创建的时候，是先创建内核数据结构呢，还是先加载对应的可执行程序呢？
答：先要创建内核数据结构，即处理好进程维护的PCB地址空间和页表对应关系，再慢慢加载可执行程序。

⑤挂起：进程对应的代码和数据全部释放掉，页表清空，并且页表标志位，对应虚拟地址所表征的是否在内存的标志位置为0代表不在内存里。

4、Linux的内存管理模块：进程管理和内存管理，实现软件层面上的解耦合

①因为有地址，空间和页表的存在将进程管理模块和内存管理模块进行解耦合

②进程=内核数据结构（task_struct＆＆mm_struct＆＆页表）+程序的代码和数据

③总结：进程具有独立性，为什么？怎么做到的？
a.每个进程具有单独的PCB和进程地址空间页表，所以在那个数据结构上，每个进程都是互相独立的。
b.只要将页表，映射到物理内存的不同区域，每个区域的代码和数据就会互相解耦。
c.把PCB换了，进程地址空间自然而然就换了。页表的起始地址属于进程的下文，进程只要切换，页表也就切换。

补充：缺页中断的好处：缺页中断本质上是重新分配内存，改变加载程序的先后顺序和单次加载量。提高首次加载速度，局部上加载速度变快。很好的将内存分批释放，减少内存申请空窗期，加快内存申请释放，从而变相是我们内存的使用率越来越高。