Linux操作系统之进程（二）：进程状态

前言

一、补充知识点

1、并行与并发

2、时间片

3、等待的本质

4、挂起

二. 进程的基本状态

三、代码演示

1、R与S

2、T

3、Z

四、孤儿进程

总结：

前言

在操作系统中，进程是程序执行的基本单位。每个进程都有自己的状态，这些状态反映了进程在系统中的当前活动情况。理解进程状态对于系统编程、性能调优和问题排查至关重要。今天，我们将深入探讨Linux进程的各种状态，并结合实际例子分析它们的行为。

一、补充知识点

在上文中我们介绍了进程的属性与进程的创建（详细查看上文链接），在了解我们本篇文章的主题——进程状态之前，我们需要给大家先补充几个知识点概念：

1、并行与并发

单核CPU执行进程代码不是把进程代码执行完毕才开始执行下一个，而是给每一个进程预分配一个时间片，基于时间片进行调度轮转（单CPU下），这通常被称为并发。

所谓并发，就是多个进程在一个CPU下采用的进程切换的方式，在一段时间之内让多个进程都得以推进。

那么所谓并行呢？就是多个进程在多个CPU下分别同时进行运行，这称之为并行。

CPU切换和运行的速度非常快，站在我们对应的这个CPU看来呢，当前这一个物理CPU它切换了多个进程，但是因为它切换和运行的速度非常快，所以用户根本就感知不到，

所以这也就解释为什么我们平时的死循环把不会程序卡死的原因，CPU会直接在操作系统的指导下，他会按照时间片来进行我们对应的轮转和调度。

2、时间片

Linux /Windows民用级别的操作系统为分时操作系统。

就是我们整个操作系统它在帮你去执行任务时，是会给每一个任务给他分配上对应的一个时间片的，比如说是10毫秒或者是1毫秒。把时间片分好之后，每一个进程在CPU上去运行时，他把自己的时间片耗尽了，他就必须得从CPU上去剥离下来，剥离下来之后再把另一个任务再放上去。这就叫做分时操作系统。没有优先级的谁高谁低，特点：调度任务追求公平，这保证了保证用户操作的及时响应。

实时操作系统通常用于VxWorks、FreeRTOS、QNX（工业/嵌入式领域），主要特点是确定性调度，任务优先级严格分级，高优先级任务可抢占低优先级任务，支持硬实时（Hard Real-Time）和软实时（Soft Real-Time）

硬实时：必须在绝对截止时间内完成（如航天控制系统）
软实时：允许偶尔超时（如视频流处理）

3、等待的本质

等待的本质：当进程需要访问外部设备（如键盘、磁盘、网络）时，若设备未就绪，CPU 不会持续轮询等待，而是将该进程移出运行队列，挂入设备的等待队列。

操作系统是怎么管理硬件的呢？也是：先描述，再组织

每个硬件设备（如键盘、磁盘）在内核中对应一个 struct device 结构体，包含：

struct device 
{unsigned int id;          // 设备唯一标识enum device_status status;// 设备状态（就绪/忙碌/错误）struct list_head wait_queue; // 等待该设备的进程队列// 其他驱动相关字段...
};

当进程需等待设备时，其 PCB 会被链入设备的 wait_queue（等待队列），直至设备触发中断通知就绪。

阻塞和运行本质上都是在等待。，只是一个在硬件的等待队列中等待，一个在CPU的运行队列中等待

当从键盘中输入数据后，操作系统会得到信息，随后又将该PCB连入运行队列。

本质上就是把一个PCB一会放在运行队列里，一会放在设备等待队列里，来回的去调用。

4、挂起

内存不足时，操作系统将非活跃进程的代码和数据换出到磁盘（Swap 分区），仅保留 PCB 在内存，这就叫做挂起。

特点是：用时间换空间：换入/换出操作增加延迟，但缓解内存压力。

在挂起后，进程变为进程变为阻塞挂起状态，挂起通常是在Swap分区里进行的。在云服务器中通常会禁掉Swap分区，这是为了防止频繁的进行换入与换出操作导致性能骤降。

二. 进程的基本状态

在Struct device中有一个status属性，这个通常记录了当前进程的状态。

我们经常在一些教科书上看见以下图片：

这样的图片肯定是无法让大家清楚的明白什么是进程的状态。

在Linux中，进程的状态通常可以通过 ps 或 top 命令查看，常见的有：

R（Running）：并不意味着进程⼀定在运⾏中，它表明进程要么是在运⾏中要么在运⾏

队列⾥。
S（Sleeping）：可中断睡眠（意味着进程在等待事件完成，如I/O）。
D（Uninterruptible Sleep）：不可中断睡眠（通常涉及硬件操作）。
T（Stopped）：进程被暂停，可以通过发送 SIGSTOP 信号（如 kill -19）给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运⾏。
Z（Zombie）：僵尸进程（已终止但未被父进程回收）。
X（Dead）：进程已完全终止（这个状态只是⼀个返回状态，你不会在任务列表⾥看到这个状态。）。

此外，还有一些特殊状态（以下并非全部）：

t（Tracing stop）：进程被调试器暂停（如 gdb 断点）。
<（高优先级） 和 N（低优先级）：调度优先级相关。

我们通常可以在终端中输入 ps ajx或ps aux来查看：

• a：显示⼀个终端所有的进程，包括其他⽤⼾的进程。

• x：显示没有控制终端的进程，例如后台运⾏的守护进程。

• j：显示进程归属的进程组ID、会话ID、父进程ID，以及与作业控制相关的信息

• u：以用户为中心的格式显示进程信息，提供进程的详细信息，如用户、CPU和内存使用情况等

三、代码演示

我们用以下代码与指令操作给大家演示一下进程各种状态的查看：

1、R与S

在当前路径中我们有以下文件：

code.cpp:

#include<stdio.h>
#include<unistd.h>int main()
{int cnt=0;while(1){printf("hello world, cnt: %d,my pid : %d\n",cnt++ ,getpid());}return 0;
}

Makefile：

# 定义编译器和编译选项
CXX = g++
CXXFLAGS = -Wall -std=c++11# 定义目标文件和可执行文件名
TARGET = code
SRC = code.cpp# 默认目标
all: $(TARGET)# 直接生成可执行文件（不生成.o文件）
$(TARGET): $(SRC)$(CXX) $(CXXFLAGS) -o $@ $<# 清理生成的文件
clean:rm -f $(TARGET)# 运行程序
run: $(TARGET)./$(TARGET).PHONY: all clean run

首先我们调用make生成可执行文件code（exe），随后输入

./code

运行code可执行文件：

随后在另外一个终端中输入

watch -n 1 '(ps ajx | head -n 1; ps ajx | grep -w "./code" | grep -v grep)'

查看进程状态：

这里有两个code进程，第一个进程是bash创建的进程组，用于管理我们在前台运行的code程序，我们不用管它，通过pid 3825121我们可以知道第二个code就是我们运行的程序，可以看见，code的进程状态（就是STAT这一栏），一直在R与S中变换（+号表示 前台进程组，受终端控制，如Ctrl+C能终止它），这是为什么呢？

进程状态切换是由 CPU时间片调度 和 I/O等待 共同作用的结果：

R+（Running）：进程正在CPU上执行，或位于运行队列等待调度。
S+（Sleeping）：进程因等待I/O（如printf到终端）被移出运行队列。

我们的code.cpp中有着printf这个函数，这会涉及到IO的相关操作，printf不是直接输出到屏幕，而是写入 标准输出缓冲区，最终通过 终端设备（如/dev/pts/0）显示。又因为终端I/O速度远慢于CPU，因此每次printf都可能触发进程阻塞（进入S状态）。

R → S：当进程调用阻塞式I/O（如printf、scanf）。

S → R：当I/O操作完成（如终端准备好接收输出）。

2、T

依旧是原来几个文件，我们继续运行code：

我们在创建一个终端，输入kill -19 +【对应进程PID】

此时我们透过之前的查看进程状态的终端可以发现，code进程已经变为了T状态：

若我们此时在输入kill -18：

又会发现：

程序又开始跑起来了，与之前不同的是，没有了+号，这是因为被中断后又继续后，进程默认变为了后台进程，此时在进程运行的终端上，输入strl c是不会终止进程的，这个时候就只能通过kill -9来杀死进程：

3、Z

在讲僵尸状态之前，我们先想一下，一个进程为什么会被创建出来呢？

一个进程会被创建出来是为了完成用户的某个任务，那么操作系统怎么知道这个任务是否完成成功了呢？

我们以前写代码，比如做题，可以通过打印信息来了解，如果打印信息无关呢？

我们更改code.cpp代码如下：

#include<stdio.h>
#include<unistd.h>// int main()
// {
//     int cnt=0;
//     while(1)
//     {
//         printf("hello world, cnt: %d,my pid : %d\n",cnt++ ,getpid());
//     }
//     return 0;
// }int main()
{int cnt=0;for(int i=0;i<10;i++){cnt++;}return 0;
}

code不再是一个无限循环代码，重新输入make生成可执行code文件并运行：

可以看见，如果没有打印信息，我们是无法知道任务完成成功了吗？

请大家在终端上输入：echo $?

我们再把code.cpp中main函数的返回值设定为11呢？

return 11;

再运行:

我们发现，这次打印出的数又变成11了。细心的同学可能就有所猜测了。

没错，我们每个程序的main函数最后都会有一个return 返回值，当我们重新正常运行结束后，会执行return语句，这个返回的数，就会被父进程接受，告诉父进程，该进程执行任务是否成功。

我们规定，返回0为执行任务成功，返回非0为失败。

进程退出时：

1、代码不会执行了，首先可以立即释放的就是进程对应的程序信息数据

2、进程退出要有退出信息，保存在自己的task_struct内部

3、管理该进程的task_struct必须被OS维护起来，方便用户未来进行获取进程退出的信息

那么这个跟Z僵尸状态有什么关联呢？大家不要着急，我们把code.cpp更改如下：

#include<stdio.h>
#include<unistd.h>// int main()
// {
//     int cnt=0;
//     while(1)
//     {
//         printf("hello world, cnt: %d,my pid : %d\n",cnt++ ,getpid());
//     }
//     return 0;
// }// int main()
// {
//     int cnt=0;
//     for(int i=0;i<10;i++)
//     {
//         cnt++;
//     }
//     return 11;
// }int main()
{pid_t id =fork();if(id==0){//子进程int n=10;while(n--){printf("i am child, pid: %d, ppid: %d\n",getpid(),getppid());sleep(1);}}else {//父进程while(1){   printf("i am parent, pid:%d\n",getpid());sleep(1);}}return 0;
}

运行并输入

watch -n 1 '(ps ajx | head -n 1; ps ajx | grep -w "code" | grep -v grep)'

查看状态：

我们可以看见，在子进程未执行完毕时，二者都是出现S+或者R+的状态，但是当我们子进程执行完毕后，可是父进程没执行完毕，就会出现僵尸状态：

僵尸状态的进程：如果没有人管我，我就会一直僵尸，task_struct会一直消耗内存→造成内存泄漏。

后面我们会讲到：一般需要父进程读取子进程信息，子进程才会自动退出。（调用waitpid），我们这里的代码没有调用waitpid，而是一直在循环，就不会去读取子进程的退出信息，导致子进程一直处于僵尸状态。

语言层面的内存泄漏的问题，如果在常驻的进程中出现，影响比较大：比如杀毒软件。

四、孤儿进程

刚刚的僵尸进程是子进程退出了，父进程还在。但如果是父进程死掉了，子进程还在呢？

更改code代码如下：

#include<stdio.h>
#include<unistd.h>int main()
{pid_t id =fork();if(id==0){//子进程while(1){printf("i am child, pid: %d, ppid: %d\n",getpid(),getppid());sleep(1);}}else {//父进程while(1){   printf("i am parent, pid:%d\n",getpid());sleep(1);}}return 0;
}

我们在第三个终端（用来输入其他指令kill时所使用的终端），输入kill指令杀死父进程：