【linux】进程状态与优先级

🔥个人主页 ：Quitecoder

🔥专栏：linux笔记仓

目录

• • 01.Linux的进程状态
  • 02.僵尸进程-Z(zombie)
  • • 处理僵尸进程
  • 03.孤儿进程
  • • 僵尸进程与孤儿进程的区别
  • 04.进程的阻塞、挂起和运行
  • • 运行状态（Running）
    • 阻塞状态（Blocked）
    • 挂起状态（Suspended）
    • 状态转换
  • 05.进程切换
  • • 上下文和寄存器

01.Linux的进程状态

为了弄明白正在运行的进程是什么意思，我们需要知道进程的不同状态。一个进程可以有几个状态（在Linux内核里，进程有时候也叫做任务），Linux更改进程状态，本质是改PCB中的状态属性

下面的状态在kernel源代码里定义：

/*
* 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）ctrl+c可以中断）。
  我们接着注释掉打印再次运行：
  

这里带加号代表我的进程在前台运行，加上&就是在后台运行

• • 当看到进程状态为 S 时，这通常意味着进程正在等待某些事件发生或者正在执行某些阻塞操作，例如等待操作系统资源（如I/O操作）变为可用。在例子中，虽然看起来只是在不停地打印信息，但 printf() 函数实际上涉及到了底层的写操作，可能是向终端或控制台输出文本。当 printf() 向标准输出写数据时，如果标准输出被连接到了慢速设备（如终端或网络操作），这些写操作可能会导致进程阻塞，等待操作系统完成数据传输。
• • 如果注释掉 printf() 调用，那么循环内将没有任何执行代码，进程只是在忙碌地循环。由于没有任何阻塞调用（如 I/O 操作） ，操作系统只是在快速地分配时间片给这个进程，让它运行。这时，进程状态大部分时间会显示为 R，因为它在 CPU 上实际执行（即使它什么也没有做），并不需要等待任何系统资源。
• • 状态 S：表示进程在某个时间点正在等待系统资源，如I/O操作（printf() 输出到标准输出）。这时进程被操作系统挂起，直到所需资源可用 。
    状态 R：表示进程在CPU上活跃执行，但由于循环中没有执行任何操作，它实际上是在空转。

[dyx@VM-8-13-centos ~]$ kill -l
 1) SIGHUP	 2) SIGINT	 3) SIGQUIT	 4) SIGILL	 5) SIGTRAP
 6) SIGABRT	 7) SIGBUS	 8) SIGFPE	 9) SIGKILL	10) SIGUSR1
11) SIGSEGV	12) SIGUSR2	13) SIGPIPE	14) SIGALRM	15) SIGTERM
16) SIGSTKFLT	17) SIGCHLD	18) SIGCONT	19) SIGSTOP	20) SIGTSTP
21) SIGTTIN	22) SIGTTOU	23) SIGURG	24) SIGXCPU	25) SIGXFSZ
26) SIGVTALRM	27) SIGPROF	28) SIGWINCH	29) SIGIO	30) SIGPWR
31) SIGSYS	34) SIGRTMIN	35) SIGRTMIN+1	36) SIGRTMIN+2	37) SIGRTMIN+3
38) SIGRTMIN+4	39) SIGRTMIN+5	40) SIGRTMIN+6	41) SIGRTMIN+7	42) SIGRTMIN+8
43) SIGRTMIN+9	44) SIGRTMIN+10	45) SIGRTMIN+11	46) SIGRTMIN+12	47) SIGRTMIN+13
48) SIGRTMIN+14	49) SIGRTMIN+15	50) SIGRTMAX-14	51) SIGRTMAX-13	52) SIGRTMAX-12
53) SIGRTMAX-11	54) SIGRTMAX-10	55) SIGRTMAX-9	56) SIGRTMAX-8	57) SIGRTMAX-7
58) SIGRTMAX-6	59) SIGRTMAX-5	60) SIGRTMAX-4	61) SIGRTMAX-3	62) SIGRTMAX-2
63) SIGRTMAX-1	64) SIGRTMAX	

用kill命令可以向指定进程发信号

kill -19 暂停进程

kill -18 继续进程

run的时候是途中红线的进程被gdb启动起来
我们还发现，运行到第九行它的状态变为t状态
遇到断点，进程就暂停了！

• D磁盘休眠状态（Disk sleep）有时候也叫不可中断睡眠状态 （uninterruptible sleep），在这个状态的进程通常会等待IO的结束。

  • 在磁盘休眠状态中，操作系统或硬件会在数据存取请求较低时，将硬盘驱动器（HDD）或固态驱动器（SSD）设置为低能耗模式。对于机械硬盘来说，这通常意味着磁盘停止旋转。对于固态硬盘，虽然没有物理旋转部件，但电力消耗可以通过降低设备的工作频率和电压来减少

  • 硬件等待：进程进入不可中断睡眠状态，通常是因为正在执行某种必须完成的硬件操作，例如等待磁盘I/O（读取或写入操作）、网络数据包或其他系统资源。这些操作涉及到与硬件的直接交互，必须在继续执行之前完成。

  • 数据完整性：此状态设计为不可中断，主要是为了保护数据完整性。如果一个进程在访问硬件时可以被信号中断，可能会在资源使用半途中被迫停止，从而导致数据不一致或者资源状态混乱。

  • 系统稳定性：保证在关键操作期间不被打断，可以避免产生悬挂锁、资源泄漏或其他内核级错误，这对系统稳定性至关重要

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

• X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态

02.僵尸进程-Z(zombie)

僵尸进程通常产生在子进程已经结束执行，但父进程尚未通过调用 wait() 或 waitpid() 系统调用来回收子进程所报告的状态信息时。在这种情况下，子进程的进程描述符（包含退出状态、进程ID等信息）仍然保存在系统中，以便父进程查询。所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态

  1 #include<stdio.h>
  2 #include<sys/types.h>
  3 #include<unistd.h>
  4 
  5 int main()
  6 {
  7     pid_t id = fork();
  8     if(id==0)
  9     {
 10         //child
 11         int cnt=5;
 12         while(cnt)
 13         {
 14             printf("I am child,cnt:%d,pid:%d\n",cnt,getpid());
 15             sleep(1);
 16             cnt--;
 17         }
 18     }
 19     else
 20     {                                                                     
 21         //parent
 22         while(1)
 23         {
 24             printf("I am parent,running,pid:%d\n",getpid());
 25             sleep(1);
 26         }
 27     }
 28     return 0;
 29 }

父进程在一个无限循环中打印信息，而子进程在完成一定次数的迭代后自行终止。没有机制来通知父进程子进程已经终止

这种状态的进程已经停止运行，完成了它的执行任务，但它的进程描述符和相关信息仍然存在于系统中，因为它等待父进程来读取其退出状态

kill不能处理僵尸进程

处理僵尸进程

1. 确保父进程调用 wait() ：编写程序时，确保父进程适当调用 wait() 或 waitpid() 来收集子进程的状态信息。这是防止进程变成僵尸进程的标准方法。

   #include <sys/wait.h>
   #include <stdlib.h>
   #include <unistd.h>
   
   pid_t pid = fork();
   if (pid == 0) {
       // 子进程
       exit(EXIT_SUCCESS);
   } else {
       // 父进程
       int status;
       waitpid(pid, &status, 0); // 等待并收集子进程状态
   }

2. 处理孤儿进程 ：如果子进程的父进程先结束了，子进程将成为孤儿进程，通常由init进程（PID为1）接管。init进程会定期调用 wait() 收集其子进程的状态，因此可以自动清理僵尸进程。

3. 发送信号：在某些情况下，如果父进程未正确处理子进程的终止，可以考虑结束父进程（确保做到安全和适当）。结束父进程后，其所有子进程将由init进程接管，这通常会清理掉任何僵尸状态的子进程。

4. 使用系统工具 ：使用像 top 或 ps 等系统监控工具来识别僵尸进程，并了解哪些父进程没有在适当的时机调用 wait()。

03.孤儿进程

通常，孤儿进程产生于以下情况：

1. 父进程执行完毕或异常终止，而子进程仍在运行。
2. 子进程由于某种原因被忽略或未能被父进程正确管理（如未调用wait()检查子进程状态）。

孤儿进程的处理

在UNIX和类UNIX系统（Linux）中，孤儿进程不会被遗弃无人管理，它们会被init进程（PID为1的进程）自动接管。init进程会周期性地调用wait()系统调用来清理其收养的孤儿进程，防止它们变成僵尸进程。

僵尸进程与孤儿进程的区别

• 孤儿进程：父进程已结束，但子进程还在运行，这些子进程被init进程接管。
• 僵尸进程 ：子进程已经结束，但父进程还未回收（调用wait()或waitpid()）子进程的相关信息（如PID、退出状态等），导致子进程虽已结束但仍占用系统资源。

编程中的应对策略

在编写涉及进程创建的程序时，应该确保：

1. 父进程能够适当地管理子进程的生命周期，包括在子进程结束时收集其状态。
2. 如有可能，设计程序结构使父子进程同步结束，避免产生孤儿进程。

  1 #include<stdio.h>
  2 #include<sys/types.h>
  3 #include<unistd.h>
  4 
  5 int main()
  6 {
  7     pid_t id = fork();
  8     if(id==0)
  9     {
 10         //child
 11         while(1)
 12         {
 13             printf("I am child,running,pid:%d\n",getpid());
 14             sleep(1);
 15         }
 16     }
 17     else
 18     {
 19         //parent
 20         int cnt=5;                                                               
 21         while(cnt)
 22         {
 23             printf("I am parent,cnt:%d,pid:%d\n",cnt,getpid());
 24             sleep(1);
 25             cnt--;
 26         }
 27     }
 28     return 0;
 29 }

父进程如果先退出，子进程就会变成孤儿进程。孤儿进程一般都是会被1号进程(OS本身)进行领养的，以此确保子进程被正常回收

直接在命令行中启动的进程，他的父进程是bash，bash会自动回收新进程的Z

04.进程的阻塞、挂起和运行

在操作系统中，进程的管理和调度是核心功能之一。了解进程的不同状态及其转换对于优化系统性能和资源管理至关重要。进程主要有三个常见状态：阻塞 、挂起 和运行。这些状态反映了进程在其生命周期中的不同阶段和活动。

运行状态（Running）

当进程正在使用 CPU 执行指令时，它处于运行状态。在这个状态下，进程的指令被实际执行。在单核处理器中，一次只能有一个进程处于运行状态；在多核处理器中，多个进程可以同时运行，每个核心一个。

处于运行状态的进程对系统性能有直接影响。操作系统必须有效地管理运行状态的进程，以确保资源的公平分配、高效利用以及系统的响应性。例如，确保不会有单个进程长时间占据 CPU 而导致其他进程饿死是调度策略设计的关键考虑

让多个进程以切换的方式进行调度，在一个时间段内同时得以推进代码，就叫做并发

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

操作系统使用调度算法来管理哪个进程应当进入运行状态。这些算法包括：

• 先来先服务（FCFS）：最简单的调度算法，按照进程到达就绪队列的顺序进行调度。
• 短作业优先（SJF）：优先调度预计运行时间最短的进程。
• 轮转调度（Round Robin）：每个进程被分配固定时间段的 CPU 时间，称为时间片，按顺序轮流使用 CPU。
• 优先级调度：基于进程优先级来调度，优先级更高的进程先获得 CPU。
• 多级反馈队列：结合多种方法，根据进程的行为动态调整其优先级。

阻塞状态（Blocked）

进程在阻塞状态时，是因为它正在等待某个事件或资源才能继续执行。例如，进程可能在等待：

• I/O请求：进行输入/输出操作时，如从硬盘读取数据或向打印机发送文档，进程会等待操作完成
• 同步操作：等待其他进程或线程通过信号量、互斥锁等同步机制释放资源
• 系统调用：执行诸如读写文件、请求网络资源等系统调用时，直到系统调用完成，进程会停留在阻塞状态
• 睡眠状态：进程可以请求系统将其置于睡眠状态，直到经过指定的时间段

处于阻塞状态的进程不会占用 CPU 资源，因为它们不能继续执行，直到阻塞条件被满足。

操作系统需要有效管理阻塞进程以确保资源的合理利用：

• 阻塞队列 ：操作系统通常会为不同类型的阻塞原因维护不同的阻塞队列。例如，I/O 阻塞队列、网络阻塞队列等。
• 事件通知机制：当阻塞事件完成时（如I/O操作完成），操作系统会通知相关进程，将其状态从阻塞转变为就绪。
• 优先级考虑：在多个进程等待同一资源时，操作系统可能根据进程优先级来决定哪个进程首先从阻塞状态恢复到就绪状态

所以，阻塞状态就是把进程从运行状态剥离出来，放到设备的阻塞队列中

挂起状态（Suspended）

挂起状态（Suspended State）是操作系统中进程状态管理的一个重要方面，涉及将进程暂时停止运行，但仍保留其在系统中的信息。挂起状态通常用于系统资源管理，特别是在内存资源紧张时 。挂起的进程可以分为两类：就绪挂起 和阻塞挂起。

• 挂起状态的特点

1. 内存释放 ：进程在被挂起时，其主存中的数据可能被移动到辅助存储（如磁盘）中，这通常称为=="换出"==操作。这有助于为运行中的进程释放宝贵的主存空间。
2. 资源管理：挂起状态使操作系统能够更灵活地管理有限的资源，如内存、处理器时间等，特别是在多任务环境下。
3. 用户控制 ：用户或系统管理员可以根据需要挂起和恢复进程，以便对系统资源进行手动调整。
   

• 挂起状态的两个子类别

• 就绪挂起（Suspended Ready）：

  • 当一个处于就绪状态的进程被挂起时，它变为就绪挂起状态。
  • 这意味着该进程已经准备好执行，所有必要的计算资源（除了CPU）都已满足，但由于某些原因（如系统资源管理策略），它被移出了主存。
  • 一旦条件允许，这个进程可以快速恢复到就绪状态，并等待CPU时间。

• 阻塞挂起（Suspended Blocked）：

  • 当一个处于阻塞状态的进程被挂起时，它变为阻塞挂起状态。
  • 这种状态通常发生在进程由于等待某些事件（如I/O操作完成）而阻塞，同时由于资源紧张等原因被换出主存。
  • 即使阻塞条件得到满足，这些进程也不能立即执行，需要先被恢复到内存中。

状态转换：

• 进程可以从就绪状态或阻塞状态转入相应的挂起状态，通常是因为系统需要为其他进程释放资源。
• 当系统资源允许，或用户请求时，挂起的进程可以被恢复到它们之前的就绪或阻塞状态。

挂起状态的管理：

操作系统通过以下机制管理挂起状态的进程：

• 交换（Swapping） ：将进程的内存数据交换到磁盘上，以释放物理内存。
• 优先级调整：系统可能根据当前的资源使用情况和进程优先级来决定哪些进程应该被挂起或恢复。
• 用户接口：提供给系统管理员或普通用户的工具和命令，用于控制进程的挂起和恢复。

操作系统能够有效地管理有限的资源，保持系统的稳定性和响应性。这种机制在服务器和多用户系统中尤为重要，可以帮助平衡负载，提高系统的整体性能和用户体验。

状态转换

• 从运行到阻塞：如果进程需要等待 I/O 操作或资源，它将从运行状态转换为阻塞状态。
• 从阻塞到运行：当阻塞的原因解除（如 I/O 完成或获取到资源），进程可以返回到运行状态。
• 从运行到就绪：如果有更高优先级的进程需要运行，当前进程可能会从运行状态转移到就绪状态。
• 从运行/阻塞到挂起：如果系统需要为其他进程腾出资源，或者用户手动暂停了进程，进程可以被挂起。

这些状态和状态转换是操作系统设计中的关键组成部分，它们确保了有效的资源管理和系统的公平性与响应性。在设计和开发操作系统或与操作系统交互的程序时，了解这些基本概念至关重要。

05.进程切换

进程切换，也称为上下文切换 （Context Switch），是操作系统中一个关键的功能，它允许多个进程共享同一处理器资源。进程切换涉及保存当前执行进程的状态和加载另一进程的状态以便继续执行。这个状态，通常被称为进程的"上下文"，包括了进程的所有寄存器和内存状态的快照。

上下文和寄存器

进程的上下文主要包括以下部分：

1. CPU 寄存器：

   • 通用寄存器：这些寄存器存储了进程执行中的临时数据、函数参数、返回值等。
   • 程序计数器（PC）：指向要执行的下一条指令的地址。
   • 堆栈指针：指向当前线程栈顶的指针，用于函数调用时参数传递和局部变量存储。
   • 状态寄存器：包含了诸如条件代码（零、负、溢出等）、模式位（指示用户模式还是内核模式）的寄存器。

2. 程序的内存状态：

   • 代码段：程序的机器指令。
   • 数据段：全局变量。
   • 堆栈：函数调用时的执行上下文，包括局部变量、调用链等。

进程切换的步骤

1. 中断或系统调用：一个进程的执行可能因为时间片耗尽、I/O请求、等待操作或高优先级进程的出现而被中断。
2. 保存上下文：操作系统保存当前进程的所有寄存器状态，以及必要的程序计数器和其他关键信息到该进程的进程控制块（PCB）中。
3. 调度决策：调度器选择另一个进程执行。
4. 恢复上下文：操作系统从即将执行的进程的PCB中恢复寄存器、程序计数器等状态信息。
5. 执行新进程：新的进程开始执行或继续执行。

性能考虑

• 开销：进程切换是有成本的。保存和恢复上下文需要时间，这就是为什么线程（轻量级进程）有时更有效，因为线程间切换通常比进程间切换要快。
• 优化：减少不必要的进程切换是优化系统性能的一个关键点。有效的调度算法尽可能减少切换次数，同时确保公平性和效率。

进程切换是现代操作系统支持多任务处理的基石，它允许单个CPU同时处理多个进程。通过有效管理进程的寄存器和内存状态，操作系统能够确保即使在频繁切换的环境中也能保持程序的正确执行和系统资源的合理利用。对于系统的设计者来说，优化进程切换的过程是提高系统响应性和效率的关键任务之一。