进程

基本概念

课本概念：程序的一个执行实例，正在执行的程序等

内核观点：担当分配系统资源（ CPU 时间，内存）的实体。

描述进程 -PCB

进程信息被放在一个叫做进程控制块的数据结构中，可以理解为进程属性的集合。

课本上称之为 PCB （ process control block ）， Linux 操作系统下的 PCB 是 : task_struct

task_struct-PCB 的一种

在 Linux 中描述进程的结构体叫做 task_struct 。

task_struct 是 Linux 内核的一种数据结构，它会被装载到 RAM( 内存 ) 里并且包含着进程的信息

task_ struct 内容分类

标示符: 描述本进程的唯一标示符，用来区别其他进程。

状态: 任务状态，退出代码，退出信号等。

优先级: 相对于其他进程的优先级。

程序计数器: 程序中即将被执行的下一条指令的地址。

内存指针: 包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针

上下文数据 : 进程执行时处理器的寄存器中的数据 [ 休学例子，要加图 CPU ，寄存器 ] 。

I／ O 状态信息 : 包括显示的 I/O 请求 , 分配给进程的 I ／ O 设备和被进程使用的文件列表。

记账信息: 可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等。

其他信息...

组织进程

可以在内核源代码里找到它。所有运行在系统里的进程都以task_struct 链表的形式存在内核里。

对进程的管理，也就变成了对链表的增删查改                         进程=PCB + 自己的代码+数据

         

只要我们的进程task_ struct在不同的队列中，进程就可以访问不同的资源

调度运行进程，本质就是让进程控制块task_ struct进行排队

进程task_ struct的内部信息有哪些？

unsigned int pid；

 d.ctrl+c在用户层面终止进程，kill -9 pid 可以用来直接杀掉进程 

kill -19 pid 暂停进程

kill -18 pid 继续运行进程，结束暂停

查看进程 

进程的信息可以通过 /proc 系统文件夹查看

如：要获取 PID 为 1 的进程信息，你需要查看 /proc/1 这个文件夹。

大多数进程信息同样可以使用 top 和 ps 这些用户级工具来获取

# ps ajx | head -l && ps ajx | grep xxx | grep -v  grep

这样能完整打印相关xxx进程的信息

通过系统调用获取进程标示符

进程id（PID）  父进程id（PPID）

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
printf("pid: %d\n", getpid());
printf("ppid: %d\n", getppid());
return 0;
}

 进程每次启动对应的pid不一样是正常的

bash是大多进程的父进程，可以创建子进程

 通过系统调用创建进程 -fork 初识

运行 man fork 认识 fork

fork 有两个返回值

父子进程代码共享，数据各自开辟空间，私有一份（采用写时拷贝）

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
    pid_t id = fork();
    if(id == -1) return 1;
    else if(id == 0)
    {
        // child
      
        while(1)
        {
      printf("id: %d, I am child process, pid: %d, ppid: %d\n",  id, getpid(),getppid());
            sleep(1); 
        }
    }
    else
    {
        // parent
        int cnt = 5;
        while(1)
        {
     printf("id: %d, I am parent process, pid: %d, ppid: %d\n",  id, getpid(),getppid());
            sleep(2);
        }
    }
 
 return 0;
}

父进程和子进程同时运行，子进程：id=0，父进程：id=子pid

父进程的代码和数据是从磁盘加载进来的

子进程的代码和数据默认继承父进程的代码和数据fork调用时子进程已经存在，同时对父子进程进行返回 id

创建一个进程本质是多一个进程，多个内核task_ struct 和 自己的代码和数据

进程状态

/*
* The task state array is a strange "bitmap" of
* reasons to sleep. Thus "running" is zero, and
* you can test for combinations of others with
* simple bit tests.
*/
static const char * const task_state_array[] = {
"R (running)", /* 0 */
"S (sleeping)", /* 1 */
"D (disk sleep)", /* 2 */
"T (stopped)", /* 4 */
"t (tracing stop)", /* 8 */
"X (dead)", /* 16 */
"Z (zombie)", /* 32 */
};

R运行状态（running）: 并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列里。
S睡眠状态（sleeping): 意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠
（interruptible sleep））。
D磁盘休眠状态（Disk sleep）有时候也叫不可中断睡眠状态（uninterruptible sleep），在这个状态的 进程通常会等待IO的结束。
T停止状态（stopped）： 可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。
X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态。

休眠状态是在等待“资源”就绪，是可中断的。

S+：在前端休眠  S：在后端休眠

t：追踪暂停    遇到断点导致的暂停

X：死亡状态（是一瞬间的我们查不出来）

D：深度睡眠状态，不可被杀，不可中断睡眠

进程向磁盘存数据时，等待磁盘时，就是这种D状态，深度睡眠状态

Z(zombie)-僵尸进程 

僵死状态（ Zombies ）是一个比较特殊的状态。当进程退出并且父进程(使用 wait() 系统调用 ）
没有读取到子进程退出的返回代码时就会产生僵死 ( 尸 ) 进程
僵死进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。
所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入 Z 状态。子进程运行完毕，但是需要维持自己的退出信息，在自己的进程task_struct会记录自己的退出信息，未来让父进程来读取，如果没用父进程读取，僵尸进程会一直存在

进程=内核数据结构task_struct+进程的代码和数据

进程的代码和数据会抹去，但task_struct会一直保留，从而导致 内存泄露问题

我们所启动的一般进程它的父进程是bash，运行结束后的z状态会瞬间被bash回收

僵尸进程杀不掉也关不掉

僵尸进程危害

进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。可父进程如果一直不读取，那子进程就一直处于Z状态？是的！

维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在task_struct(PCB)中，换句话说，Z状态一直不退出，PCB一直都要维护？是的！
那一个父进程创建了很多子进程，就是不回收，是不是就会造成内存资源的浪费？是的！因为数据结构 对象本身就要占用内存，想想C中定义一个结构体变量（对象），是要在内存的某个位置进行开辟空间！ 内存泄漏?是的！

孤儿进程

父进程如果提前退出，那么子进程后退出，进入 Z 之后，那该如何处理呢？

父进程先退出，子进程就称之为“孤儿进程”

孤儿进程被 1 号 init 进程领养，当然就是 init 进程回收喽。父进程如果先退出，子进程就会变成孤儿进程，孤儿进程一般都是会被1号进程(OS本身)进行领养的，孤儿进程为什么要被OS领养，依旧要保证子进程正常被回收

进程的阻塞，挂起和运行 

进程切换进程在运行队列中，就是R状态.

一个进程一旦持有CPU,会一直运行到这个进程结束吗

不会，基于时间片进行轮转调度的，让多个进程以切换的方式进行调度，在一个时间段内同时得以推进代码，这就叫并发。

任何时候，都同时有多个进程在真的同时运行，我们叫做并行

阻塞态

等待键盘资源是否就绪，键盘上面有没有被用户按下的按键，按键数据交给进程

阻塞和运行的状态变化，往往伴随这pcb被连入不同的队列中

入队列的是进程的task_struct

挂起态

相关理解

task_struct体积还是挺大的 

进程优先级

cpu资源分配的先后顺序，就是指进程的优先权（priority）。

优先权高的进程有优先执行权利.配置进程优先权对多任务环境的linux很有用,可以改善系统性能。

还可以把进程运行到指定的CPU上，这样一来，把不重要的进程安排到某个CPU，可以大大改善系统整体性能

指定进程获取某种资源的先后顺序

为什么要有优先级

查看系统进程

在linux或者unix系统中，用 ps -l 或者 ps - al 命令则会类似输出以下几个内容：

调整进程优先级

用 top 命令更改已存在进程的 nice ：

top

进入 top 后按 “r”–> 输入进程 PID–> 输入 nice 值

PRI也还是比较好理解的，即进程的优先级，或者通俗点说就是程序被CPU执行的先后顺序，此值越小，进程的优先级别越高
那NI呢?就是我们所要说的nice值了，其表示进程可被执行的优先级的修正数值
PRI值越小越快被执行，那么加入nice值后，将会使得PRI变为：PRI(new)=PRI(old)+nice
这样，当nice值为负值的时候，那么该程序将会优先级值将变小，即其优先级会变高，则其越快被执行
所以，调整进程优先级，在Linux下，就是调整进程nice值
nice其取值范围是-20至19，一共40个级别

每次调整优先级都是从80开始

新的优先级= 80 + nice，nice属于[-20，19]

 命令行参数和环境变量

命令行参数

装的都是执行指令的字符串argc是指令字符串个数，argv[argc]=NULL

环境变量

环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数

如：我们在编写C/C++代码的时候，在链接的时候，从来不知道我们的所链接的动态静态库在哪里，但 是照样可以链接成功，生成可执行程序，原因就是有相关环境变量帮助编译器进行查找。
环境变量通常具有某些特殊用途，还有在系统当中通常具有全局特性
Linux中存在一些全局的设置,表明,告诉命令行解释器，应该去那些路径下去寻找可执行程序
这就是环境变量

环境变量包含（等等）：
PATH : 指定命令的搜索路径
HOME : 指定用户的主工作目录 ( 即用户登陆到 Linux 系统中时 , 默认的目录 )
SHELL : 当前 Shell, 它的值通常是 /bin/bash 。

查看环境变量方法

系统中很多配置，比如环境变量，在我们登录Linux系统的时候，已经被加载到bash进程中

默认我们查到的环境变量都是内存级的

bash在执行命令的时候，需要从环境变量中先找到命令，因为未来要加载.

最开始的环境变量不是在内存中，而是在系统的对应的配置文件中，环境变量默认是在配置文件中。之后导入内存中的bash进程。所以我们将我们的文件路径导进配置文件，那就永久存在了

指令env可以查看所有环境变量  export: 设置一个新的环境变量，导入我们自己的环境变量unset: 清除环境变量

设置本地变量 本地变量可以被echo打印,但是不在环境变量中

本地变量只在bash内部有效,无法被子进程继承

要用export导入环境变量表

 通过代码如何获取环境变量

1.获取整个环境变量2.获取一个环境变量

所以环境变量默认也是可以被子进程拿到的

 ​​​​​bash进程会给子进程环境表 export导入的是这个环境变量表，不是配置文件

总结： 

子进程获取环境变量的方法：

内建命令

内建命令由bash进程亲自执行，不需要在环境变量中的PATH路径中寻找

export、echo都是内建命令

程序地址空间

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
 
int g_val = 100;
 
 
int main()
{
    printf("father is running, pid: %d, ppid: %d\n", getpid(), getppid());
 
 
    pid_t id = fork();
    if(id == 0)
    {
        //child
        int cnt = 0;
        while(1)
        {
            printf("I am child process, pid: %d, ppid: %d. g_val: %d, &g_val: %p\n", getpid(), getppid(), g_val, &g_val);
            sleep(1);
            cnt++;
            if(cnt == 5)
            {
                g_val = 300;
                printf("I am child process, change %d -> %d\n", 100, 300);
            }
        }
    }
    else
    {
        //father
        while(1)
        {
            printf("I am father process, pid: %d, ppid: %d. g_val: %d, &g_val: %p\n", getpid(), getppid(), g_val, &g_val);
            sleep(1);
        }
    }
}

 父子进程是具有独立性的

进程=内核数据结构(task_struct) + 代码(只读)和数据(会修改)

子进程会把父进程的很多内核数据结构全拷贝一份

代码和数据用的是同一份

g_val变量在父子进程中的值不一样，虚拟地址是一样的，但物理地址不一样

地址空间的本质就是内核中的一个结构体对象

os自主完成写时拷贝，通过调整拷贝的时间顺序，达到有效节省空间的目的

同一个变量，地址相同，其实是虚拟地址相同，内容不同其实是被映射到了

不同的物理地址！

如何理解地址空间

区域划分地址空间本质是内核中的一个struct结构体，内部很多的属性都是表示start，end的范围地址空间通俗的讲就是操作系统给进程所占数据空间所画的物理空间的大饼

为什么要有地址空间

1.将无序变成有序，让进程以统一的视角看待物理内存以及自己运行的各个区域

2.进程管理模块和内存管理模块进行解耦

3.拦截非法请求，对物理内存进行保护

如何理解页表和写时拷贝

 字符串常量无法修改就是在访问物理内存之前被拦截

OS识别相关错误

1.是不是数据不在物理内存中 ->缺页中断

2.是不是数据需要写时拷贝  ->发生写时拷贝

3.如果都不是，才进行异常处理 ->.....

如何理解虚拟地址

在最开始的时候，地址空间页表里面的数据从哪来

答：程序里面本身就有地址（虚拟地址）（逻辑地址）

 编译完成就会有虚拟地址

虚拟地址被cpu读取，去页表中找物理地址。

所以内存中编译完既会产生虚拟地址，也有物理地址，cpu循环读取虚拟地址找物理地址

Linux真正是如何调度的

nice属于[-20,19],40个数字，优先级属于[60,99]，0-99下标位置的队列不用，只用100-139

[100,139]下标位置和[[60,99]优先级是映射关系

Linux系统中每一个CPU都有一个运行队列

遍历位图，0-139下标位置的位图：1则有队列，0则没有队列

bitmap[5]表示160位的位图两个运行队列分别进满了和出完了，就会交换指针。进出的功能也就交换了

一个 CPU 拥有一个 runqueue

优先级

普通优先级： 100 ～ 139 （我们都是普通的优先级，想想 nice 值的取值范围，可与之对应！）

实时优先级： 0 ～ 99 （不关心）

活动队列

时间片还没有结束的所有进程都按照优先级放在该队列

nr_active: 总共有多少个运行状态的进程

queue[140]: 一个元素就是一个进程队列，相同优先级的进程按照 FIFO 规则进行排队调度 , 所以，数组下标就是优先级！

从该结构中，选择一个最合适的进程，过程是怎么的呢？
1. 从 0 下表开始遍历 queue[140]
2. 找到第一个非空队列，该队列必定为优先级最高的队列
3. 拿到选中队列的第一个进程，开始运行，调度完成！
4. 遍历 queue[140] 时间复杂度是常数！但还是太低效了！

bitmap[5]: 一共 140 个优先级，一共 140 个进程队列，为了提高查找非空队列的效率，就可以用 5*32 个比特位表示队列是否为空，这样，便可以大大提高查找效率

过期队列

过期队列和活动队列结构一模一样

过期队列上放置的进程，都是时间片耗尽的进程

当活动队列上的进程都被处理完毕之后，对过期队列的进程进行时间片重新计算

active 指针和 expired 指针

active 指针永远指向活动队列

expired 指针永远指向过期队列

可是活动队列上的进程会越来越少，过期队列上的进程会越来越多，因为进程时间片到期时一直都存在的。
没关系，在合适的时候，只要能够交换 active 指针和 expired 指针的内容，就相当于有具有了一批新的活动进程！

总结

在系统当中查找一个最合适调度的进程的时间复杂度是一个常数，不随着进程增多而导致时间成本增加，我们称之为进程调度O(1) 算法