【Linux】进程管理：状态与优先级调度的深度分析

已于 2024-10-13 00:02:54 修改
阅读量2k 收藏 84
点赞数 91
分类专栏： Linux学习 文章标签： linux 运维 服务器
于 2024-10-03 17:39:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/island1314/article/details/142682055
版权

✨                                                  山海自有归期，风雨自有相逢      🌏 

📃个人主页：island1314

🔥个人专栏：Linux—登神长阶

⛺️ 欢迎关注：👍点赞 👂🏽留言 😍收藏  💞 💞 💞

1. 前言 🚀

🌈之前在这篇文章揭秘计算机内部奥秘：从CPU到操作系统，深入探索进程与线程的工作原理中就已经简述了 进程的部分相关内容，下面我们来进一步深入了解进程的内容。

🔥进程的基本概念

🍅 我们在编写完代码并运行起来时，在我们的磁盘中会形成一个可执行文件，当我们双击这个可执行文件时（程序时），这个程序会加载到内存中，而这个时候我们不能把它叫做程序了，应该叫做进程。

🍅 所以说，只要把程序（运行起来）加载到内存中，就称之为进程。
🍅 进程的概念：程序的一个执行实例，正在执行的程序等。
🍅 如果站在内核的角度来看：进程是分配系统资源的单位。

2. 描述进程-进程控制块（PCB）

2.1 基本概念

🌈前面说了一个抽象的概念需要一个具体的结构体来进行描述的。进程中的信息就被放在了一个叫做进程控制块(PCB)的结构体中。

在不同的操作系统下进程控制块的名称不同（比如：不同地方的人称呼某一个东西有不同的叫法）

  • 在Linux操作系统中PCB的具体名称是：task_struct

🧩当一个程序被加载到内存中要开始执行的时候，操作系统同时会给该进程分配一个PCB，在Linux中就是task_struct这里面包含了所有关于进程的数据信息。所以CPU对task_struct进行管理就相当于对进程进行管理。

🍊 task_struct 是Linux内核的一种数据结构，它会被装载到 RAM(内存) 里并且包含着进程的信息,在进程执行时，任意时间内，进程对应的 PCB 都要包含以下内容：

  1. 标识符：与进程相关的唯一标识符，用来区别其他进程
  2. 状态：进程会有不同的状态，如运行，停止等等
  3. 优先级：相对于其他进程的优先顺序
  4. 程序计数器：程序中即将执行的下一条指令的地址
  5. 内存指针：包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针
  6. 上下文数据：进程执行时CPU的寄存器中的数据
  7. IO状态信息： 包括显示的I/O请求，分配给进程的I/O设备和正在被进程使用的文件列表。
  8. 记账信息：可能包括处理器时间总和，使用的时钟总数，时间限制，记账号等
  9. 其他信息：... 暂且了解上面八个即可，其他就不做过多了解

 2.2 分类详解

🌸 进程标识符：描述本进程的唯一标示符，用来区别其他进程

也就是进程的PID，【PID】是操作系统中唯一标识的进程号

有两个获得【进程PID】的方式：

  1. 可以使用ps aux查看进程的信息。

  2. 可以使用系统接口得到进程PID和父进程的PPID 

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

int main() {    
    printf("pid=%d, ppid=%d\n", getpid(), getppid()); // 进程号和父进程号
    return 0;    
}

    🍉PPID 的解释：

🌸 进程状态：

进程有很多的不同的状态，在kernel源代码中是这样定义的

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 */
};

（1）R- -可执行状态（运行状态）

  • 只有在运行状态的进程才有可能在CPU上运行，注意是可能，并不意味着进程一定在运行中。同一时刻可能有多个进程处在可执行状态，这些进程的PCB（进程控制块）被放入对应CPU的可执行队列中。然后进程调度器从各个可执行队列中分别选择一个进程在CPU上运行。
  • 另外如果计算机只有一个处理器，那么一次最对只有一个进程处于这种状态。

（2）S- -可中断睡眠状态（sleeping）

  • 处在这个状态意味着进程在等待事件完成。这些进程的PCB（task_struct结构）被放入对应时间的等待队列中。然后等待的事件发生时，对应的进程将被唤醒。

（3）D- -不可中断睡眠（disk sleep）

  • 在这个状态的进程通常会等待IO的结束。
  • 这个状态与sleeping状态相似，处于睡眠状态，但是此刻进程是不可中断的，意思是不响应异步信号。
  • 另外你会发现处在D状态的进程kill -9竟然也杀不死。这就相当于我们怎么也叫不醒一个装睡的人。

（4）T- -暂停状态

  • 给进程发送一个SIGSTOP信号，进程就会响应信号进入T状态，除非该进程正处在D状态。
  • 再通过发送SIGCONT信号让进程继续运行。
  • kill -SIGSTOP
  • kill -SIGCONT

（5）Z- -僵尸状态

  • 僵死状态是一个比较特殊的状态。进程在退出的过程中，处于TASK_DEAD状态。
  • 在这个退出过程中，进程占有的所有资源将被回收，除了task_struct结构（以及少数资源）以外。于是进程就只剩下task_struct这么个空壳，故称为僵尸。

（6）X- -死亡状态或退出状态（dead）

  • 死亡状态是内核运行 kernel/exit.c ⾥的 do_exit() 函数返回的状态。这个状态只是⼀个返回状态，你不会在任务列表里看到这个状态

🌸 进程优先级：

  • 🌿因为CPU资源有限，而进程却有很多个，所以需要优先级这个属性去决定了进程拿到资源的顺序。

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

🌿CPU有三个工作：取指令，分析指令和执行指令。CPU中的指令寄存器每一次都会保存下一条指令的地址，以此来进行指令判断。

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

🌸上下文数据

通常操作系统内核使用一种叫做**「上下文切换」**的方式来实现控制流。

实行这种机制是因为CPU只有一套寄存器，所有只能有将一个进程的存储数据放入寄存器中计算，从而形成了上下文数据。但是同时有多个进程的时候，操作系统为了使得CPU的利用率最高，所以会让进程之间来回的切换，一般进程切换有两种情况：

  1. 我们称两个执行流在执行的时间上与另一个执行流有重叠的部分，就称这个两个执行流在 「并发的运行」。一个进程在和其他的进程轮流轮流运行成为 「多任务」。一个进程执行它的控制流的那一段时间叫做 「时间片」。简单来说，每一个进程都会有最多执行的时间限制，如果执行时间超过了时间片，就会自动的退出执行

  2. 当操作系统内核，发现一个优先级更高的进程的时候，该优先级更高的进程就会「抢占」当前进程的位置，然后执行优先级更高的进程。等到该进程执行完后，在执行被 「抢占」 的进程。这种决策方式叫做 「调度」

以上两种情况，都会使得进程意外的退出CPU的执行，但是下次CPU还想接着上一次执行的地方继续执行那个意外退出的进程，所以就需要在进程退出之前，在task_struct中保留下上一次执行的数据，方便下一次再被执行。

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

3. 查看进程 🔍

查看进程有三种方式：

3.1 通过系统目录

🍊 在 /proc 这个目录下保存着所有进程的信息。
⚡ 注意：/proc不是磁盘级别的文件

3.2 通过ps命令

ps aux # 查看系统中所有的进程信息
ps axj # 可以查看进程的父进程号

# 一般的合并操作如下
ps ajx | head -1 && ps ajx | grep 可执行程序/pid

3.3 通过top命令

top命令是一个可以动态查看进程信息的命令（很像windows中的任务管理器）

top # 动态的查看进程的信息，其中的信息默认3秒回更新，按 q 退出

4. 创建进程 --fork() 📃

🍎进程的创建一般有两种方式：

  1. 使用./运行某一个可执行程序，这种是最常见的方式
  2. 使用系统调用接口创建进程，即使用fork()

当时用 fork() 函数之后，就在原来的进程中创建了一个子进程，在 fork() 之前的代码只被父进程执行，在 fork() 之后的代码有父子进程一起执行。

创建的子进程和父进程几乎一模一样，子进程和父进程的共享地址空间，子进程可以或者父进程中所有的文件，只有PID是父子进程最大的不同（注：PID是进程标识符，在上面描述进程里有说）

先来个最简单的案例1：

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

int main()
{
    printf("main 函数的 pid: %d, ppid: %d\n",getpid(), getppid());
    pid_t id = fork();
    if(id < 0){
        printf("Error\n");
    }
    else if(id == 0){
        printf("我是子进程, pid: %d, ppid: %d\n",getpid(), getppid();
    }
    else{
        printf("我是父进程, pid: %d, ppid: %d\n",getpid(), getppid());
    }
}

结果及分析

对于 fork 函数的进一步理解：

案例2 如下：

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

int gval = 0;

int main()
{
    printf("I am a process, pid: %d, ppid: %d\n", getpid(), getppid());
    pid_t id = fork();

    if(id > 0){
        while(1){ // 父进程只读 gval，不做修改
            printf("我是父进程, pid: %d, ppid: %d, gval:%d\n", getpid(), getppid(), gval);
            sleep(2);
        }
    }
    else if(id == 0){
        while(1){ //子进程对 gval 读 + 修改
            printf("我是子进程, pid: %d, ppid: %d, gval: %d\n", getpid(), getppid(), gval);
            gval++;
            sleep(2);
        }
    }
    return 0;
}

案例3：

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

int main()    
{    
    fork();    
    fork();    
    printf("hello\n");    
    return 0;    
}

上面应该是输出了4个 hello，下面这张图就可以解释

💖结论：一个父进程可以创建多个子进程，因此我们可以知道 Linux 进程 整体就是一种 树形结构

这里面有很多有意思的点：

fork函数调用一次，返回两次

  • 🎯 上面的代码是如何实现执行两个不同的分支语句的呢？其实是因为fork函数会返回两个返回值，一个是子进程会返回0，一个是父进程会返回子进程的PID。所以会同时进程两个分支语句中。

并发执行

  • 🎯 父子进程是两个并发运行的独立程序。并发（同一个cpu执行），就是两个执行流在执行的时间上有重叠的部分。也就是说父子进程谁先被调度是不能确定的。

相同但是独立的地址空间

  • 🎯 两个进程其实地址空间是一样的，但是它们都有自己私有的地址空间，所以父子进程的运行都是独立的，一个进程中的内存不会影响另一个进程中的内存。

共享文件

  • 🎯 子进程继承了父进程所有打开的文件， 
    #include <stdio.h>
int main()
{
    while (1) 
    {
     	printf("hello world\n");
        sleep(100); // 睡眠100秒
    }
    return 0;
}
    所以父进程调用fork的时候，stdout文件呢是打开的，所以子进程中执行的内容也可以输出到屏幕上

5. 进程状态 📚

5.1 基本知识

小知识：

1. kill 指令

2. shell 脚本监控

# 每隔一秒就查看进程的信息
while :; do ps ajx | head -1 && ps ajx | grep a.out | grep -v grep; sleep 1; done

我们在上面描述进程中已经看过了部分知识，下面是对之前的一个补充

5.2 状态演示

 （1）R运行状态,，S运行状态

  1. 处于R状态的进程有的在cpu中执行，但是很多都是在运行队列中等待运行，也就是该进程允许被调度。
  2. S这种状态是一种浅度睡眠，此时的进程是在被阻塞的状态中，等待着条件的满足过后进程才可以运行。在这种状态下可以被信号激活，也可以被信号杀死。
  3. 可以使用sleep() 系统调用接口使得一个进程睡眠

案例：

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

int main()
{
  int cnt = 0; 
  while(1)
  {
    scanf("%d", &cnt);
    printf("hello world, cnt: %d \n", cnt++);
  }
  return 11;
}

为啥带了printf之后，查出的状态就是S状态？

  • 因为一个时间片的进程是非常短的，根据冯诺依曼体系，printf 打印的时候不是向显示器直接打印，而是往内存去写的，相当于显示器也有自己的缓存，但是如果疯狂写入，缓存很容易写满，导致显示器并不能时时刻刻就绪的，虽然每一次都能看到打印的信息
  • 但其实 printf有 I/0，因此这一份代码看似死循环，其实在死循环的过程中99%情况大部分时间都在做 I/0 的。
  • 因为 I/0 速度比较慢因此当它在while中检测该条件，执行printf代码，才能真正叫作运行状态(R状态)
  • 也就是 放到运行队列里，被CPU 所调动时，其状态才叫作R状态，很多时候进程都处于等待状态(S状态)，因为外设不一定就绪.

（2）D磁盘休眠状态
这种状态是一种深度休眠的状态，在这种状态下即使是操作系统发送信号也不可以杀死进程，只能等待进程自动唤醒才可以。

模拟实现：

这种情况没法模拟，一般都是一个进程正在对IO这样的外设写入或者读取的时候，为了防止操作系统不小心杀掉这个进程，所以特地创建出一个状态保护这种进程。

案例：

（3）T停止状态

可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。

模拟实现：

可以使用信号

kill -SIGSTOP PID 		// 停止进程， 可以用 kill -19 来替代
kill -SIGSONT PID 		// 继续进程， 可以用 kill -18 来替代

 案例：

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

int main()
{
  while(1)
  {
    printf("I am a process, pid: %d, ppid: %d\n", getpid(), getppid());
    sleep(1);
  }
  return 0;
}

分析及理解：

补充一个知识：

  • 前后台任务：

 我们可以发现在前台任务执行时，输入其他指令也不会产生别的影响，而在后台任务中，我们输入的每个指令都会有相对应的输出，因此我们可以知道：

  • 前台任务用户直接与之交互的任务或程序。用户可以通过输入、点击等方式与这些任务进行实时的交互。通常会占用用户的注意力
  • 后台任务：不需要用户直接交互，且可以在用户进行其他操作时继续运行的任务。用户不需要关注它们的进程

（4）X死亡状态

  • X进程停止执行，进程不能投入运行。通常这种状态发生在接受到SIGSTOP、SIGTSTP、SIGTTIN、SIGOUT等信号的时候。

可以使用kill -9 PID即可杀死一个进程，上面我们也用到了 kill -9 .

（5）Z僵尸状态

  • 僵死状态（Zombies）是一个比较特殊的状态。当进程退出并且父进程（使用wait()系统调用,后面讲）
  • 没有读取到子进程退出的返回代码时就会产生僵死(尸)进程
  • 僵死进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。

所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态

案例：

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

int main()
{
  printf("父进程运行：pid: %d ,ppid: %d\n", getpid(), getppid());

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

5.3 孤儿进程

🌈如果父进程比子进程先退出，那么此时子进程就叫做孤儿进程。而操作系统不会让这个子进程孤苦伶仃的运行在操作系统中，所以此时孤儿进程会被init进程（也就是1号进程，即所有进程的祖先）领养，从此以后孤儿进程的状态和最后的PCB空间释放都是由init进程负责了。

5.4 僵尸进程

a. 为什么会出现僵尸进程？

  • 前面说过进程的作用是为了给操作系统提供信息的，所以在进程调用结束之后，应该将该进程完成的任务情况汇报（exit code）给操作系统，但是进程在执行完之后已经结束了，所以此时进程的状态就是僵尸状态。

b. 僵尸进程的概念

  • 僵尸进程：即进程已经结束了，但是父进程没有使用wait()系统调用，此时父进程不能读取到子进程退出返回的信息，此时就该进程就进入僵死状态。

c. 僵尸进程的危害

  • 进程已经结束了，但是进程控制块PCB却还是没有被释放，这时就会浪费这一块资源空间。所以会导致操作系统的内存泄漏。

d. 如何消灭僵尸进程？

  • 僵死状态需要父进程发出wait()系统调用终止进程，如果父进程不终止进程，那么此时要消灭僵尸进程只能通过找到僵尸进程的父进程，然后kill掉这个父进程，然后僵尸进程就会成为孤儿进程，此时由init进程领养这个进程然后杀死这个僵尸进程。

具体演示在上面已经写过，大家可以在上面自行查看。

5.5 进程状态转换

6. 进程优先级 📒

6.1 基本概念

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

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

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

6.2 进程优先级的意义

之所以会存在进程优先级，是因为cpu本身的资源分配是有限的，一个cpu一次只能run一个进程，但是一个操作系统中可能会有成千上百的进程，所以需要存在进程优先级来确定每一个进程获得cpu资源分配的顺序。

6.3 查看进程优先级

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

注：ps -l 查看 进程优先级 信息，ps -al 查看整个系统的 优先级信息

其中我们来了解几组关于进程优先级的相关信息：

  1. UID : 代表执行者的身份
  2. PID : 代表这个进程的代号
  3. PPID ：代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号
  4. PRI ：代表这个进程可被执行的优先级，其值越小越早被执行
  5. NI ：代表这个进程的nice值
  6. Linux的默认优先级是80

6.4 PRI 和 NI 的异同

PRI和NI是一组对应的概念。NI的取值会影响到PRI的最终值。

PRI代表进程被CPU执行的先后顺序，并且 PRI越小进程的优先级越高。NI代表nice值，表示进程的优先级的修改数值。所以两者之间有一个计算的公式：(new)PRI = (old)PRI + NI。

注意：

  1. 1. PRI 在系统中默认为 80

2. NI 的取值范围为 [-20，19]，一共40个级别 

相异之处：

  • 需要强调一点的是，进程的nice值不是进程的优先级，他们不是一个概念，但是进程nice值会影响到进程的优先级变化。
  • 可以理解nice值是进程优先级的修正数据。

6.5 修改进程优先级

（1）通过top命令更改nice值

top命令 上面有说明，这里我们就直接使用了。

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

（2）通过renice命令更改nice值）

语法格式：renice nice值 进程PID

6.6 NI 为什么会在可控范围内

该问题即 为啥Linux的优先级调整会被限制？

🥑由于我们现在用的系统都是分时操作系统，进程调度需要保证尽量公平，而只有在可控范围内才不会影响到我们的公平调度。如果不受限制，自己可以将自己的进程的优先级设置非常高，而系统的，或者别人的非常低，优先级较高的进程获得资源，后续还有很多今后曾源源不断产生，会导致常规进程享受不到资源。造成进程饥饿问题。

6.7 其它概念

前面一直在介绍单个进程的概念，下面我们稍微了解一下多个进程之间的关系概念。

  1. 竞争性： 系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更合理竞争相关资源，便具有了优先级。
  2. 独立性：多个进程运行，需要独享各种资源，多个进程运行期间互不干扰。
  3. 并发：多个进程在一个CPU下采用进程切换的方式，在一段时间内，让多个进程都得以推进，称之为并发，所以两个并发的进程之间在执行之间上有重叠的部分。
  4. 并行：多个进程在多个CPU下同时运行，称之为并行。

补充：

等待的本质

阻塞：每一个 CPU 都会给 操作系统 提供一个叫作 运行队列的东西。只要进程在运行队列中，该进程就叫作 运行状态，表示我已经准备好了，可以被 CPU 随时调度。

了解完阻塞之后，我们就可以知道卡顿的本质：是CPU 不调动 它了，有以下两种原因：

  1. ① 就是该进程在等待外设，比如键盘数据输入
  2. ② 系统内的进程过多

7. 进程切换及调度 🤯

在讲解具体知识前，我们先来了解相关知识：

时间片

Linux / windows 民用级别的操作系统，分时操作系统 --> 调度任务追求公平

🎯 进程在运行的时候，放在CPU上，并不是需要将该进程的代码全部执行完才会被拿下CPU，现代操作系统，都是基于时间片进行轮转执行，一个进程在CPU上有一个执行最大时间，即时间片，在CPU上执行了该时间，就会被拿下

7.1 基本理解 

 进程切换（process switch）是操作系统的核心任务之一，用于在不同进程之间进行 CPU 时间的共享和分配。当一个进程在运行时，它占用了 CPU，并占用了其他诸如内存等资源。当操作系统需要执行另一个进程时，就需要进行进程切换。进程切换涉及到保存当前进程的上下文信息，包括 CPU 寄存器、程序计数器、栈指针等，以及恢复调度执行下一个进程所需的上下文信息。

在 Linux 操作系统中，进程切换的实现源码可以分为两个部分：进程调度 和 上下文切换。

  • 进程调度负责决定当前应该将哪个进程分配给 CPU 执行；
  • 上下文切换则是在进程切换时，保存当前进程的上下文信息，并恢复调度执行下一个进程所需的上下文信息。

进程调度的代码主要位于kernel/sched/ 目录下，包括了进程调度算法以及实现。而进程切换则需要涉及到进程的 PCB（进程控制块）和线程的 TCB（线程控制块），以及 CPU 的寄存器状态和内核栈等上下文数据。在 x86 架构的处理器上，进程切换的具体实现涉及到  task_switch 函数、 switch_to 宏以及 switch_to_asm 汇编函数等。在 AArch64 等不同架构的处理器上，对应的汇编代码可能有所不同，但目的是一致的。

7.2 进程切换

 CPU里面有大量的寄存器，比如：eax，ebx,ecx,edc，eds/ecs,eip… 等等，当一个进程在CPU 上被运行的时候，这些寄存器会围绕这个进程进行展开运算，保存相关的在执行该进程代码中的信息，临时数据，比如变量，函数等等。

  1. 其中 epi 也就是我们所说的 pc指针，记录进程执行到哪里了（比如PC记录的是一个进程代码的50行，则说明当前执行的是第49行）。这能保证进程在切换回来后还是继续往后执行。
  2. 当一个进程在CPU上的时间到了，要被拿下CPU时，需要将CPU上关于该进程的所有数据（大多是寄存器上的数据）（被称为进程的硬件上下文）全部保存带走，这些数据有些保存到进程的PCB中，有些保存在其他地方，较为复杂。这个过程叫 保护上下文。
  3. 这个进程被拿下后，CPU里面的寄存器的数据还是上一个进程的旧数据，当这些寄存器需要存储新的进程的相关数据时，直接覆盖式的写入即可。
  4. 如果是首次调度该进程，就直接从代码开头运行即可，如果不是首次调度，进程被放到CPU上运行时，则需要先把上次的硬件上下文数据进行恢复(恢复上下文)，然后根据 eip寄存器 中保存的上次代码执行的位置继续执行。
  5. CPU内的寄存器只有一套，虽然寄存器数据放在了共享的CPU是设备里面，但是所有的数据，其实都是被进程私有的

总结：进程在被执行的过程中，一定会存在大量的临时数据，会暂存在 CPU 内的寄存器中。

我们把进程在运行中产生的各种寄存器数据，我们叫进程的硬件上下文数据。

  • 当进程被剥离：需要保存上下文数据
  • 当进程恢复时：需要将曾经保存的上下文数据恢复到寄存器中。

调度器根据保存的进程上下文，就可以实现进程切换

7.3 进程调度 

进程调度的核心代码实现参考kernel/sched 目录文件，主要包含以下几个部分：

  1. 调度算法：Linux 中实现了多种不同的进程调度算法，如 CFS（Completely Fair Scheduler）、O(1) 调度算法、实时调度算法等，并且各个算法之间可以配置和切换，由用户指定默认调度器。（注：Linux实现进程调度的算法，需要考虑优先级，考虑饥饿，考虑效率）
  2. 调度队列：调度算法的实现需要用到调度队列，它通过双向链表的数据结构来管理所有进程。Linux 中有就绪队列、休眠队列、实时队列等不同类型的队列，它们存储着不同状态的进程。
  3. 进程状态：Linux 中的进程状态有很多种，如 TASK_RUNNING（运行中）、TASK_INTERRUPTIBLE（可中断的）、TASK_UNINTERRUPTIBLE（不可中断的）、TASK_STOPPED（已停止的）等。进程在不同状态下会被放置到不同类型的调度队列中，以便进行合适的调度。

  • 🔥 活跃队列

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

  • nr_active：总共有多少个运行状态的进程
  • queue[140]：  一个元素就是一个进程队列，相同优先级的进程按照FIFO规则进行排队调度,所以，数组下标就是优先级！
  • 先看蓝色框内的内容，有个叫 queue[140] 的数组，这里的 queue 数组表示活动状态进程的进程队列
  • 其中在queue数组中，索引【0~99】号下标我们是不用的，这是因为0-99号下标对应的是 实时进程的优先级，实时进程是内核里更加重要的进程，放在前100位由操作系统控制，避免系统抢占的情况。
  • 所以我们只剩下 [100-139] 这个范围可操控，其实这也就和我们优先级的可控范围大小相同，正好对应队列的四十个空位，而OS通过某种映射关系，将可控优先级映射到数组 【100-139】的下标
  • 从该结构中，选择一个最合适的进程，过程是怎样的呢？

1. 从0下表开始遍历queue[140]
2. 找到第一个非空队列，该队列必定为优先级最高的队列
3. 拿到选中队列的第一个进程，开始运行，调度完成！
4. 遍历queue[140]时间复杂度是常数！但还是太低效了，因此我们就用到了下面的位图判断。

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

🔥 位图判断

🍊  bitmap数组，类型为int，这个数组用来干嘛呢？只能存储5个整形变量。数组的名字叫做bitmap已经很明显了，就是位图，5个整形元素有 32 * 5 = 160 个比特位，比特位的位置，表示哪一个队列。比特位的内容，表示该队列为不为空。

比如：0000 … 0000 ，如果最左侧0对应queue[100]的位置，那么如果该比特位为0表示在该下标映射的优先级下该队列为空，否则不为空。

那么为什么要用位图？

  • 遍历整个队列的时间开销要远大于查找位图。
  • 所以，bitmap是用来检测队列中是否有进程，检测对应的比特位是否为1！

在蓝色框内还有一个元素：nr_active ，在 Linux 中，nr_active 是运行队列中用于表示活跃进程数量的计数器。nr_active  的值可以告诉内核有多少进程正在等待执行，从而帮助内核进行进程调度和资源分配。

🔥 过期队列

🍅在红色框中的三项属性与蓝色框中的三项属性完全相同，也就是另外一个队列，被称为——过期队列。

活跃队列表示当前CPU正在执行的运行队列，而 正在执行的运行队列（也就是活跃队列）是不可以增加新的进程的。

所以操作系统设置了一个 和活跃队列相同属性的过期队列，当活跃队列正在执行时如果有进程需要添加进运行队列，那么就会添加至过期队列当中，也就是说 活跃队列的进程一直在减少，而过期队列中的进程一直在增多！

当活跃队列的进程执行完毕后，就会和过期队列进行交换，它们交换的方式是通过两个结构体指针：

  • 就是  active 和 expired 结构体指针，它们分别指向 活跃队列和过期队列，而活跃队列与过期队列由于属性完全相同，于是被放在了一个叫做prio_arry_t[2] 的数组里，prio_arry_t[0] 指向活跃队列，prio_arry_t[1]指向过期队列
  • 当活跃队列被CPU执行完毕后，我们 只需要交换两个指针的内容即可，这样仅仅只有指向的内容变了，然后活跃队列变为过期队列，过期队列变活跃队列，并且时间复杂度为 O(1)：
  • 新增进程在过期队列里插入，此时正在执行的是活跃队列，所以这个时候在过期队列里就有时间处理竞争饥饿的问题了。

总结：

  • 进程切换最重要的部分就是进程上下文的保护和恢复。
  • 进程调度的优先级问题由 活跃进程数组的下标与进程优先级形成一种映射关系 解决。
  • 进程调度的时间复杂度问题由 位图和两个结构体指针 解决，时间复杂度控制在了O(1)。
  • 进程调度的进程饥饿问题由 活跃队列 和 过期队列 解决。

补充：

 active 指针和 expired 指针

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

7.4 上下文切换

上下文切换的核心代码实现参考arch/x86/kernel/process.c或者 arch/arm64/kernel/process.c等架构相关的文件，主要包含以下几个部分：

  • 进程控制块（Process Control Block, PCB）：PCB 是 Linux 内核用来存储和管理进程信息的重要数据结构。在进程切换时，需要将当前进程的 PCB 中保存的上下文信息保存到内存中。
  • 内核栈：内核栈用来保存进程的运行状态，进程切换时需要把当前进程的内核栈保存到当前进程的 PCB 中，并从新进程的 PCB 中恢复对应的内核栈信息。
  • 寄存器状态：CPU 中包含了多个寄存器，进程切换时需要将当前进程的寄存器状态保存到当前进程的 PCB 中，并从新进程的 PCB 中恢复寄存器状态。
  • 进程上下文切换：在 Linux 中，进程上下文切换是通过 switch_to 宏实现的。该宏会将当前进程的上下文信息保存到 PCB 中，并从新进程的 PCB 中读取上下文信息，完成进程切换的操作。

需要注意的是，不同架构的处理器可能会有不同的实现，但其核心原理相同。

📖 小结

以上就把进程概念、描述、查看、状态、优先级以及调度切换讲完了，后面我会更新 关于 命令行参数以及环境变量 的博客，让我们一起努力学习，一起加油吧！！！

💖💞💖【*★,°*:.☆(￣▽￣)/$:*.°★* 】那么本篇到此就结束啦，如果我的这篇博客可以给你提供有益的参考和启示，可以三连支持一下 ！！

IsLand1314~
关注
专栏目录
进程优先级的艺术调控：Linux中nice与renice命令的深度指南
07-11
Linux是一种开源的、基于Unix的操作系统内核，由林纳斯·托瓦兹（Linus Torvalds）在1991年首次发布。它遵循自由软件和开源开发的原则，任何人都可以自由地使用、修改和分发Linux内核。Linux内核是操作系统的核心部分，负责管理系统资源，如任务调度、文件系统、设备驱动程序、内存管理等。 Linux的主要特点包括： 1. **开源**：Linux的源代码对所有人开放，任何人都可以查看、修改和重新发布。 2. **多用户多任务**：Linux支持多用户同时使用系统，并且可以同时运行多个任务。 3. **稳定性和安全性**：Linux系统以其稳定性和安全性而闻名，适合长时间运行而不需要重启。 4. **跨平台**：Linux可以在多种硬件平台上运行，包括个人电脑、服务器、移动设备、嵌入式系统等。 5. **丰富的软件生态**：有大量的开源软件可用于Linux，用户可以根据自己的需要选择和使用。 6. **定制性**：用户可以根据需要定制Linux系统，包括内核编译选项、系统服务、软件包等。 7. **社区支持**：Linux有一个庞大的开发者和用户社区，为
Linux调度器：进程优先级.pdf
07-31
总结来说，Linux进程优先级是调度器决策的重要依据，它涉及到用户空间的nice值、实时优先级，以及内核中的静态优先级、实时优先级和归一化优先级。理解这些概念及其相互关系，有助于系统管理员和开发者更好地优化...
Linux进程状态与优先级
m0_74830524的博客
05-06 2208
本篇详细的讲解了 Linux 中进程会出现的各种状态，以及出现这些状态的原因，其中进程的阻塞、挂起和运行就是进程状态的体现。接着科普了一下进程的切换，然后讲解了进程的优先级，以及如何调整进程的优先级。最后对进程的特点进行了总结。
Linux：进程状态和优先级
weixin_51142926的博客
09-16 3590
进程的状态和优先级是我们需要深入理解的！！
Linux系统编程：进程的状态和进程优先级
weixin_43908419的博客
06-24 925
本文讲解了进程的状态和优先级相关概念
Linux进程管理一（进程原理与分析）
weixin_43155199的博客
03-02 1317
创作人QQ：851301776，邮箱：lfr890207@163.com 欢迎大家一起技术交流，本博客主要是自己学习的心得体会,只为每天进步一点点！ 个人座右铭： 1.没有横空出世，只要厚积一定发。 2.你可以学历不高，你可以不上学，但你不能不学习 一、进程原理 1.进程 Linux内核把进程称为任务（task），进程的虚拟地址空间分为用户虚拟地址空间和内核虚拟地址空间，所有进程共享内核虚拟地址空间，每个进程有独立的用户虚拟地址...
Linux入门：进程状态，优先级与进程调度
Lvision2的博客
10-18 1020
—》cpu资源分配的先后顺序，就是指进程的优先权（priority）
波奇学Linux:Linux进程状态，进程优先级
Boki
12-12 1030
进程状态和进程优先级，Linux实现优先级调度
linux内核源码分析进程的管理与调度
热门推荐
weixin_52259848的博客
08-30 2万+
linux内核源码分析进程的管理与调度
零基础Linux_8(进程)操作系统进程状态和Linux进程状态+进程优先级
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
09-27 515
零基础Linux_8（进程）操作系统进程状态（运行+终止+阻塞+挂起）+Linux进程状态（RSDTXZ）+孤儿进程+进程优先级（优先级修改和切换）。
Linux小黑板(2):进程优先级与进程状态
RNGWGzZs的博客
12-15 479
任意时刻,进程都有可能会因调度 从cpu上拿下来，换上另外一个 优先级更高 或者 因超时而被换下..... 那么，如果这个被“切换下”的进程如果再次被调度呢？在我们实际使用中的计算机,恐怕不会遇见 只能开一个或者几个进程,而其他进程起 不来的情况吧？但是,当我们使用电脑的时候,不仅仅只会 启动一个程序！总有进程能够有机会 或许在(到来的时间上,或是"nice"值上.....)既是存在再多CPU也有 无限的进程 里的代码需要被执行！优先级 ---->(能的基础上) 先后！这也就是 所谓的优先级的概念！
Linux进程深度解析：源码、调度与控制
`task_struct`是Linux内核中表示进程的核心数据结构，包含了诸如进程ID、父进程ID、进程状态、调度信息、内存管理信息、文件系统信息等所有与进程相关的信息。每个进程都有一个与之对应的`task_struct`结构体实例。...
Linux内核分析：进程调度与控制的研究
Linux采用不同的调度策略，如轮转调度、优先级调度等，以优化系统性能和响应时间。内存管理子系统则涉及到物理内存的分配、释放以及虚拟地址空间的管理，包括页表、分页机制等，确保内存的有效利用和程序的隔离。...
Linux特种文件系统--tmpfs文件系统
刘元林的博客
10-29 1113
tmpfs类似于RamDisk（只能使用物理内存），使用虚拟内存（简称VM）子系统的页面存储文件。tmpfs完全依赖VM，遵循子系统的整体调度策略。说白了tmpfs跟普通进程差不多，使用的都是某种形式的虚拟内存，至于数据存储在物理内存中还是在交换分区中，全权交由VM子系统。定义： 是一个基于内存的文件系统，它在 RAM 中存储数据，因此访问速度非常快。用途： 通常用于存储临时文件，这些文件不需要永久保存，而且频繁读写。使用 可以减少对物理磁盘的磨损，并提高性能。示例路径：常见的 挂载点包括 、、 等。持
Camp4-L0：Linux 前置基础
fangsfdavid的博客
10-29 888
书生浦语大模型实战营第四期：Linux前置基础
【Linux】MySQLMGR主从复制
Stringzhua的博客
10-30 889
MySQL是⽬前最流⾏的开源关系型数据库，国内⾦融⾏业也开始全⾯使⽤，其中MySQL5.7.17提出的 MGR(MySQL Group Replication)既可以很好的保证数据⼀致性⼜可以⾃动切换，具备故障检测功能、 ⽀持多节点写⼊，MGR是⼀项被普遍看好的技术。MGR(MySQL Group Replication)是MVSQL⾃带的⼀个插件，可以灵活部署。
Linux 之 信号概念、进程、进程间通信、线程、线程同步
挥剑决浮云的博客
11-01 669
如果释放互斥锁时有一个以上的线程阻塞，那么这些阻塞的线程会被唤醒，它们都会尝试对互斥锁进行加锁，当有一个线程成功对互斥锁上锁之后，其它线程就不能再次上锁了，只能再次陷入阻塞，等待下一次解锁。事实上，子进程是父进程的一个副本，譬如子进程拷贝了父进程的数据段、堆、栈以及继承了父进程打开的文件描述符，父进程与子进程并不共享这些存储空间，这是子进程对父进程相应部分存储空间的完全复制，执行fork()之后，每个进程均可修改各自的栈数据以及堆段中的变量，而并不影响另一个进程。是一族函数，而不是一个单独的函数。
『 Linux 』网络传输层 - TCP(二)
最新发布
小侯宝的博客
11-01 886
为什么是三次握手三次握手是TCP为了保证双方通信时具有可靠性所定制的一种策略;而三次握手可以确保客户端和服务端至少都向对方发送了一次消息,从而确保连接建立的更为可靠;以朴素的角度来看三次握手实际上也可以被解析成四次握手;但为了提升连接创建的效率,TCP采用捎带应答的策略,在第二次握手中将ACK报文与SYN报文整合成了一个报文,即为SYN+ACK报文;在三次握手中能够确保双端都对对方进行一次消息的发送以及消息的接收来确保连接的稳定,因此三次握手中任何一次握手都不能少;
1Panel 是新一代的 Linux 服务器运维管理面板
qq_44534541的博客
10-29 495
1Panel 是一款新一代的 Linux 服务器运维管理面板，旨在通过现代化的 Web 界面帮助用户轻松管理 Linux 服务器。它集成了主机监控、文件管理、数据库管理、容器管理等功能，并且支持多语言和国际化，包括英语、中文(繁体)和日语。
评论 85
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值