最新资讯

欢迎来到ZyyOvO的博客✨，一个关于探索技术的角落，记录学习的点滴📖，分享实用的技巧🛠️，偶尔还有一些奇思妙想💡
本文由ZyyOvO原创✍️，感谢支持❤️！请尊重原创📩！欢迎评论区留言交流🌟
个人主页 👉 ZyyOvO
本文专栏➡️Linux驾驭之道 掌控操作系统的艺术与哲学

引言

书接上回，我们认识了冯诺依曼体系结构，了解了操作系统的概念，以及库函数和系统调用的区别，最后我们讲了进程的概念以及如何在系统中查看存在的进程。
忘记的点这里，光速复习！👉 Linux进程概念
本文将带领大家继续探索进程这座神秘的大山！主要围绕进程状态展开，带领大家进一步的揭开进程的神秘面纱。

在开始之前，我先给大家灌输一个观点:

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

• 内核数据结构就是我们上节课讲到的 进程控制块PCB,(process control block)，在Linux操作系统下叫做task_struct,是Linux内核中定义的结构体。
• 自己的代码就是进程所对应的要执行的程序指令序列，在进程运行时被操作系统加载到内存中由CPU执行。
• 自己的数据就是进程在运行过程中需要处理和操作的数据集合，包括全局变量、局部变量、堆内存中分配的数据等。

如何理解，进程=内核数据结构+自己的代码和数据呢？？？

举个例子，大学生毕业之后要找工作，找工作需要投递简历吧？那么你的简历里就记录了你的详细信息，包括毕业学校，实习经历，项目经验，包括你的学校的学习状况等等。那么你的简历就相当于进程的内核数据结构，Linux下叫做task_struct，其中包含了进程的所有详细信息，包括PID（进程标识符），PPID（父进程标识符），exit_code（进程的退出码），exit_signal（进程的退出信号）等等。
你自己本人就相当于进程的代码和数据，当你的简历被HR选中要求你去公司面试时，本质上就是进程的代码和数据加载到内存被CPU执行！

说到这里，希望大家能对这句话有个大概的了解，听不懂也没关系，后面我们会不止一次提到，等进程这个话题讲完，相信大家会对这句话有更深刻的理解。

系统调用fork

在继续探索Linux系统中的进程状态之前，我先带大家认识一个系统调用fork，这是我们初次接触系统调用函数，后面我们会遇到更多系统调用，也会对系统调用了解的更加深刻！

我们在Linux系统中使用 man 2 fork 指令可以看到fork系统调用的详细说明。

FORK(2)                                                                    Linux Programmer's Manual                                                                    FORK(2)

NAME
       fork - create a child process

SYNOPSIS
       #include 

       pid_t fork(void);

• 头文件为
• 函数原型为pid_t fork(void);

接下来我们为大家详细介绍fork函数

函数功能

• fork函数用于创建一个新的进程，称为子进程。
• 子进程是调用fork函数的进程（父进程）的一个副本，它几乎与父进程完全相同，包括程序计数器、内存内容、打开的文件描述符等。这里我还不能给大家展开，只要记住子进程的内核数据结构以及代码和数据都是从父进程拷贝过来的，并且做了小部分的修改，例如修改PID和PPID等。

总结一句话就是，哪个进程调我，我就给它创建子进程。

子进程和父进程可以同时执行，它们各自有独立的执行路径，可以分别进行不同的操作。互不影响!

返回值

对父进程：

• 如果函数调用成功，fork函数返回子进程的进程 ID（PID）。这个 PID 是一个正整数，用于标识新创建的子进程，父进程可以通过这个PID 来对特定的子进程进行后续的操作，如等待子进程结束、向子进程发送信号等。

为什么要给父进程返回子进程的PID呢？

• 因为一个父进程可以通过fork函数创建多个子进程，父进程：子进程=1：N 如果不把子进程的PID返回给父进程，那么父进程将来如何管理自己的多个子进程呢？换句话说，父进程怎么知道哪个孩子是哪个呢？

所以给父进程返回子进程的PID是为了父进程能够更好的管理子进程！

• 如果fork函数调用失败，它将在父进程中返回 -1，并设置errno变量来指示错误原因。常见的错误原因包括系统资源不足、达到了系统对进程数量的限制等。

对子进程：

• 在子进程中，如果函数调用成功，fork函数返回 0。这是子进程识别自己的方式，通过判断fork的返回值为 0，子进程可以知道自己是新创建的进程，从而执行特定于子进程的代码逻辑。
• 如果调用失败，子进程没有被创建，无返回值。

代码层面理解

• 创建子进程：当父进程调用fork函数时，操作系统内核会为子进程分配新的进程控制块（PCB）和其他必要的资源，如内存空间等。子进程的内存空间最初是父进程内存空间的一个副本，但它们之间的内存是相互独立的，后续对内存的修改不会相互影响。

我们通过代码来让大家进一步的理解fork函数，在开始之前，我们需要补充两个函数，同样是系统调用。

• getpid（）和getppid（）

GETPID(2)                                                                  Linux Programmer's Manual                                                                  GETPID(2)

NAME
       getpid, getppid - get process identification

SYNOPSIS
       #include 
       #include 

       pid_t getpid(void);
       pid_t getppid(void);

getpid是一个用于获取进程标识符（PID）的系统调用，getppid则是获取父进程的进程标识符。

头文件：

• #include 和 #include
• 返回值为调用进程的PID，不在赘述

一句话总结，对于getpid（）来说哪个进程调我，我就返回哪个进程的PID！
对于getppid（）来说，哪个进程调我，我就返回哪个进程的父进程的PID！

代码示例：

#include
#include
#include
int main()
{
    int rid=fork();
    if(rid < 0)
    {
        //返回值<0 说明创建子进程失败 打印错误信息并退出
        perror("fork");
        return 1;
    }
    else  if(rid == 0)
    {
        //如果返回值rid为 0，说明这是子进程
        //打印它的pid和父进程的pid
        printf("我是子进程，我的pid是：%d,我的父进程pid是%d
",getpid(),getppid());
    }
    else 
    {
        //走到这里说明返回值不为0，则是父进程
        printf("我是父进程，我的pid是：%d,我的父进程pid是%d
",getpid(),getppid());
    }
}

输出：

[zwy@iZbp1dkpw5hx2lyh7vjopaZ myshell]$ ./a.out
我是父进程，我的pid是：23558,我的父进程pid是20723
我是子进程，我的pid是：23559,我的父进程pid是23558

这里我们看到：

• 父进程的PID为23558，PPID为20723
• 子进程的PID为23559，PPID为23558

确实父进程的PID对应着子进程的PPID，表明fork函数确实为我们当前的进程创建了子进程！

看到这里，可能会有很多同学有疑问了？为什么一个函数有两个返回值？？fork是如何给父子进程分别返回不同的值？？为什么一个变量既可以让if成立，又可以让else成立？？？

小小的脑袋有着大大的问号，别急我们一个一个回答！

1. 对于第一个问题：为什么一个函数有两个返回值？

根据同学们以往对C语言学习的经验，一个函数只能有0个或者1个返回值，那么这里为什么fork可以返回两个值呢？
我们可以这么理解，当我们一个函数执行到return 语句的时候，函数的主体功能是否已经做完了呢？答案是肯定的，当函数开始return时，函数的功能已经基本实现，对于fork函数来说，当它开始返回时，子进程已经被创建，此时fork函数会分别给父进程和子进程进行返回，此时fork就会返回两个值，分别作为父进程和子进程fork函数的返回值！

2. 对于第二个问题：fork是如何给父子进程分别返回不同的值？

我们之前讲过，子进程的内核数据结构以及代码和数据都是从父进程那里拷贝过来的，但是做了相应的修改.我们知道进程具有独立性! 如果父子进程中有任何一方想要修改共享的数据，那么就会触发操作系统的写时拷贝（后面会讲），操作系统会拷贝一份新的出来，让想要修改的进程去修改新拷贝出来的数据，从而保证进程之间的独立性。
那么无论是哪个进程先被fork返回，此时返回值rid已经有了值，那么当另一个进程返回时，操作系统发现它要修改父子进程的共享数据，那么就会触发写时拷贝，会拷贝新的数据用来给它返回修改（当然中间会有相当复杂的机制，包括进程地址空间，页表等操作系统层面的知识），此时就完成了fork给父子进程返回不同的值！

3. 对于第三个问题：为什么一个变量既可以让if成立，又可以让else成立？

对于这个问题，我们目前解释不清楚，但是我们可以肯定这个变量肯定不是存储在物理内存中，如果在物理内存中，根据地址拿到变量的值，为什么子进程和父进程的值不一样呢？实际上我们C语言中学的指针中指向的地址都是虚拟地址，并不是真实的物理地址，这个问题我们留到进程的虚拟地址空间给大家讲清楚！

进程状态

如同人一样，当你在上课时，你的状态是听课中，当你在睡觉时，你的状态时休息中，当你在排队打饭时，你的状态是等待中，当你在打篮球时，你的状态时运动中…
进程也同样如此，有着不同的状态，方便我们对进程更好的管理和操作！

我们先来看一下操作系统学科中，对于进程状态的划分：

Linux内核源代码

下面的进程状态在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): 意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠 （interruptiblesleep）。
• D 磁盘休眠状态（Disk sleep）有时候也叫不可中断睡眠状态uninterruptible sleep，在这个状态的进程通常会等待IO的结束。
• T 停止状态（stopped）： 可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。
• X 死亡状态（dead）：这个状态只是⼀个返回状态，你不会在任务列表里看到这个状态。

进程状态查看

ps aux / ps axj 命令

• a：显示⼀个终端所有的进程，包括其他用户的进程。
• x：显示没有控制终端的进程，例如后台运行的守护进程。
• j：显示进程归属的进程组ID、会话ID、父进程ID，以及与作业控制相关的信息
• u：以用户为中心的格式显示进程信息，提供进程的详细信息，如用户、CPU和内存使用情况等。

我们可以通过ps结合grep命令实现对指定进程状态的查看

ps ajx | grep Test

[zwy@iZbp1dkpw5hx2lyh7vjopaZ ~]$ ps ajx | grep Test
20723 30085 30085 20723 pts/1    20723 R     1000   6:32 ./Test
29974 32651 32650 29974 pts/0    32650 R+    1000   0:00 grep --color=auto Test

同时结合head命令将第一行信息提取出来

 ps ajx | head -1 && ps ajx | grep Test

[zwy@iZbp1dkpw5hx2lyh7vjopaZ ~]$ ps ajx | head -1 && ps ajx | grep Test
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723 30085 30085 20723 pts/1    20723 R     1000   7:52 ./Test
29974 32719 32718 29974 pts/0    32718 R+    1000   0:00 grep --color=auto Test

还可以通过grep -v grep 将含有grep的信息过滤掉，防止干扰查找。

ps ajx | head -1 && ps ajx | grep Test | grep -v grep

[zwy@iZbp1dkpw5hx2lyh7vjopaZ ~]$ ps ajx | head -1 && ps ajx | grep Test | grep -v grep
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723 30085 30085 20723 pts/1    20723 R     1000   9:23 ./Test

top命令

终端中直接输入

top

启动后，你会看到一个动态的界面，界面中会显示系统的总体信息（如负载、CPU 使用率、内存使用率等）以及各个进程的详细信息。

常用交互操作

• q：退出 top 界面。
• M：按内存使用率排序。
• P：按 CPU 使用率排序。
• 1：显示每个 CPU 核心的使用情况。

- 运行状态（R，Running）

进程正在 CPU 上执行，或者正在等待 CPU 资源，只要获得 CPU资源就可以立即执行。处于该状态的进程是活跃的，正在参与系统的运算和处理。

int main()  
 {
	while(1)
	{
		;
    }
    return 0;                                                                                                                                                                   
 }            

我们写一个死循环的程序，成功编译运行后，成为一个进程。此时我们每隔一秒对进程状态查看一次，会发现进程一直处于运行状态。
命令：

while true; do ps ajx | head -1; ps ajx | grep "Test" | grep -v grep;   sleep 1; done

PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723 29872 29872 20723 pts/1    29872 R+    1000   0:06 ./Test

其中R+，R表示进程处于运行状态，后面的+号表示该进程属于前台进程组的成员，在前台运行，会导致命令行占用，无法输入命令。这个我们可以不用关心！

如果想要让进程成为一个后台进程组的进程，即在后台运行，不影响命令行的输入，可以在启动进程时加上&符号。
例如：

[zwy@iZbp1dkpw5hx2lyh7vjopaZ myshell]$ ./Test &
[2] 791

此时进程会进入后台运行，不影响前台的操作。

PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723   791   791 20723 pts/1    20723 R     1000   2:28 ./Test
20723 30085 30085 20723 pts/1    20723 R     1000  20:41 ./Test

- 睡眠状态（S，Sleeping） 也称为可中断睡眠状态。

进程正在等待某个事件完成或资源可用，比如等待 I/O操作完成、等待信号量等。在等待期间，进程会被挂起，不会占用 CPU 资源。当等待的事件发生或资源变为可用时，进程会被唤醒，进入运行队列等待CPU 调度。

同样的程序，我们加上一句printf输出。

int main()  
 {
	while(1)
	{
		printf("pid:%d
",getpid());
    }
    return 0;                                                                                                                                                                   
 }   

编译运行后，成为一个进程，不断地在终端打印PID。

pid:2171
pid:2171
pid:2171
pid:2171
pid:2171

此时我们查看进程状态。

 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723  2810  2810 20723 pts/1     2810 R+    1000   0:09 ./Test
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723  2810  2810 20723 pts/1     2810 R+    1000   0:09 ./Test
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723  2810  2810 20723 pts/1     2810 S+    1000   0:10 ./Test
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723  2810  2810 20723 pts/1     2810 S+    1000   0:10 ./Test
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723  2810  2810 20723 pts/1     2810 S+    1000   0:11 ./Test
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723  2810  2810 20723 pts/1     2810 R+    1000   0:11 ./Test

发现进程居然是一会处于R+状态，一会处于S+状态，这时就会有同学产生疑惑了？
我们程序的不是一止死循环的向终端打印吗？有R+状态我能理解，但是为什么会有S+状态呢？？为什么会处于浅度休眠状态？

这是因为我们的程序中有printf函数，涉及到了IO操作，当程序要进行IO操作时，可能会处于浅度休眠状态，因为要占用硬件资源，向显示器打印，这时有可能其他进程正在使用，所以我们的进程就会进入浅度休眠状态，为S+状态，等硬件资源就绪后，就会进入运行状态，变为R+状态，被CPU调度执行，这就是为什么会一会R+状态，一会S+状态！

还有一种情况，当我们的程序中使用sleep函数时，进程也会进入S状态。

例如：我们让它每隔一秒钟打印一次，此时就会处于S状态。

int main()  
 {
	while(1)
	{
		printf("pid:%d
",getpid());
		sleep(1);
    }
    return 0;                                                                                                                                                                   
 }   

PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723  3652  3652 20723 pts/1     3652 S+    1000   0:00 ./Test
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723  3652  3652 20723 pts/1     3652 S+    1000   0:00 ./Test
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723  3652  3652 20723 pts/1     3652 S+    1000   0:00 ./Test
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723  3652  3652 20723 pts/1     3652 S+    1000   0:00 ./Test

有同学又会问了，为什么进程会一直处于S+状态呢？我们不是还有printf打印操作吗，也需要转为R状态被CPU执行啊，那是因为printf执行的速度太快了，我们每隔一秒查一次进程状态，而CPU执行程序的时间可能只需要几微秒，甚至纳秒，大部分都处于sleep休眠时间，此时我们无法查到进程的R状态，进程表现为S浅度休眠状态！

- 阻塞状态（D，Disk Sleep）也叫不可中断睡眠状态。

与可中断睡眠状态类似，进程也是在等待某个事件或资源，但处于这种状态的进程不能被信号中断，通常用于一些特殊的情况 比如进程正在进行磁盘I/O 操作，为了保证数据的完整性和一致性，在操作完成之前不允许被中断。

讲个故事理解：

浅度睡眠的进程是可以直接被操作系统杀掉的，因为操作系统是进程的管理者，有权力杀死一个进程。

例如，用户编写了一个程序要把10GB（这里只是假设数据量比较大）的数据写入磁盘的文件中，程序运行后，成为一个进程。

这时进程通过操作系统提供的接口找到磁盘，对着磁盘说：“磁盘，帮我存10GB的数据到一个指定的文件里”。

• 磁盘回答说：“好的进程，你等会啊，先别走，我看看我磁盘里面还有没有足够的空间，不管存不存的下，我等会给你答复，你先别走啊！”说着便一头扎进去找地方了。
  进程答道：“行，我在这等你，快点回来奥。”此时进程躺在椅子上睡着了，进入了浅度睡眠状态，即S状态。

• 这时操作系统正在忙的焦头烂额，看到了躺在椅子上睡着的进程，非常生气，大喊道：“进程，你在干什么！你没看看我都忙成什么样子了，你居然还在这里睡觉，我看你是不想活了”说着就要把进程杀掉。

• 进程急忙回答：“操作系统你别生气，用户让我把这10GB的数据写入磁盘，我给磁盘说了让它赶紧把数据找个地方写进去，它让我在这等它，到现在也没出来，也不知道存进去了没有，我也没办法，用户交给我的任务，我必须得完成啊”
  操作系统此时正处于气头上，二话不说的将进程杀掉了！此时进程瞬间消失的无影无踪。

• 操作系统便急忙走了，系统内存空间严重不足了，操作系统此时任务很艰巨，它知道它无论如何绝不能让系统崩溃，这是它的使命！

• 过了不大一会，磁盘探出来个头问道“进程啊，不行了，我里面没有空间了，你快去告诉用户，磁盘空间不足，这10GB数据存不下去了，让用户想想办法吧！进程？进程？？进程？？？”磁盘大喊道，可是只传来空荡荡的回音，进程已经死了。这10GB的数据也丢失了。

• 用户发现它的数据迟迟没有写入磁盘，惊恐的发现自己的进程已经被操作系统杀掉了，同时10GB数据也丢失了。非常生气，找来操作系统，进程，磁盘三个人当面对质！你们三个怎么搞的，到底谁的错，一个一个说吧！！

• 进程先说到：“用户啊，你让我去告诉磁盘把这10GB的数据写入磁盘，我跟他说了，他让我在外面等他，能不能存进去它会给我个回答，我再告诉你，我一直再尽职尽责啊，我总不能任务没完成，也不知道写没写进去就回来吧，万一没写进去，10GB的数据也丢了，我必须得在那等磁盘啊！”

• 用户看了看进程，觉得它说的很有道理。

• 此时，操作系统立马说到：“用户啊，你知道的，我一直都是你最衷心的的追随者，一年365天没日没夜的给你干活，只要你需要，我从来没喊过一句苦，一句累，不管多难我都帮你每时每刻维护着系统的稳定和安全，今天系统的内存空间已经严重不足了，随时都有挂掉的风险，我看他还在那里睡觉，我实在忍不了了，就把他杀了，这才勉强让系统挺了过去，你也不想让我挂掉吧，这要是我挂掉了，可就不是丢掉10GB数据这么简单了。”

• 用户一直都比较信赖操作系统，听操作系统这么一说，觉得它一点都没错！

• 此时用户看着磁盘，磁盘吓得赶忙说道：“用户啊，你知道的，我就是整个计算机里最底层的人，人家让我干啥我就干啥，人家让我怎么干，我就怎么干，今天人家进程让我把你的10GB数据写进去，我立马就在里面找空间了，虽然我一直很努力的找，但是我实在找不到这么大的地方了，我出来告诉进程的时候，他已经被操作系统杀了，那我也没办法啊，我就是个跑腿的”

• 用户看着磁盘可怜的模样，觉得它也没错。

• 用户想了想说，这样吧，你们三个都没错，以后我给进程新增一个特权，当进程在进行大规模的IO操作时，操作系统你无权杀掉它，只能等它IO操作结束自行退出，无论系统多忙你都无权杀掉他！出了问题我负责。进程你也别怕，以后你在和磁盘IO时没有人能打扰你，更不敢杀掉你，你就放心大胆的完成我交给你的任务！此时三个人都觉得不错

这个给进程新增的特权就叫做D状态，也叫做不可中断休眠状态！

这个状态我们目前观察不到，需要涉及大文件块的传输。

- 僵尸状态（Z，Zombie）

当子进程已经终止运行，但它的父进程还没有调用wait()或waitpid()系统调用来获取它的退出状态时，进程就会进入僵尸状态。处于僵尸状态的进程已经释放了大部分资源，但仍保留了一些进程控制块信息，等待父进程来回收。

举个例子：

int main()
{
    pid_t id = fork();
    if (id < 0)
    {
        perror("fork failed!
");
        exit(1);
    }
    else if (id == 0)
    {
        int cnt = 3;
        while (cnt--)
        {
            sleep(1);
            printf("我是一个子进程 我的pid：%d,我的父进程pid: %d
", getpid(), getppid());
        }
    }
    else
    {
        printf("我是一个父进程 我的pid：%d,我的父进程pid：%d
", getpid(), getppid());
        while (1);
    }
    return 0;
}

通过 fork() 系统调用创建了一个子进程，然后父进程和子进程分别执行不同的代码逻辑：

• 父进程：打印自身及其父进程的 PID，随后进入一个无限循环，持续运行而不回收子进程的资源。
• 子进程：打印 3 次自身及其父进程的 PID，每次打印间隔 1 秒。当子进程完成 3 次打印后，会自然退出。

由于父进程没有调用 wait() 或 waitpid() 来回收子进程的退出状态，子进程退出后会变成僵尸进程。

 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723  6726  6726 20723 pts/1     6726 R+    1000   0:02 ./process
 6726  6727  6726 20723 pts/1     6726 S+    1000   0:00 ./process
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723  6726  6726 20723 pts/1     6726 R+    1000   0:03 ./process
 6726  6727  6726 20723 pts/1     6726 Z+    1000   0:00 [process] <defunct>
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
20723  6726  6726 20723 pts/1     6726 R+    1000   0:04 ./process
 6726  6727  6726 20723 pts/1     6726 Z+    1000   0:00 [process] <defunct>

可以看到

• 前3秒，子进程处于S状态，父进程处于R状态。
• 3秒后，子进程运行完毕退出，父进程处于死循环的R状态，但是父进程没有对子进程的退出状态进行回收，此时子进程就会进入僵尸状态，成为一个僵尸进程。

举个例子，理解僵尸进程

正常情况

• 在一个小镇上，每个人就像系统里的进程，警察负责管理人口信息。假设居民张三，他的活动就类似进程在执行任务。张三的家属好比进程的父进程。
  当张三正常离世时，家属会立刻通知警察，告知张三的死亡情况以及可能的死因等信息。警察接到通知后，会从人口记录里把张三的信息正式注销，释放掉原本为张三记录预留的空间，这就如同父进程在子进程正常结束后，调用
  wait() 或者 waitpid() 函数，获取子进程的退出状态并释放子进程占用的系统资源。此时，系统资源得以正常回收，不会有多余的负担。

僵尸进程情况

• 然而，某天居民李四意外死亡了。李四的家属（父进程）由于沉浸在悲痛中，或者因为一些特殊原因，没有及时向警察（系统）报告李四的死讯。
• 这时，李四虽然已经去世（子进程已经终止），但警察那边的人口记录里，李四的信息依然存在（进程控制块仍然保留），而且一直处于一种待处理的状态。警察既不能把李四的信息直接删除，因为不确定他是否真的死亡；也不能让新的居民使用这个记录位置，因为李四的记录还在占用着。这就好比子进程结束后，父进程没有调用wait() 或 waitpid() 来获取子进程的退出状态，子进程就变成了僵尸进程，虽然不再运行，但依旧占用着系统的进程表项资源。

僵尸进程的特点体现

• 占用资源但不工作：就像小镇上李四的人口记录一直占着系统表格的位置，僵尸进程占用着系统的进程表空间，可实际上它已经不进行任何有效的工作了。
• 等待处理：李四的信息等待家属来告知警察进行处理，僵尸进程等待父进程调用相应的函数来获取退出状态并释放资源。只要父进程不采取行动，僵尸进程就会一直存在。

一句话总结，子进程退出后，父进程不对子进程的退出信息回收，子进程就会进入僵尸状态，父进程一直不处理，子进程就一直处于僵尸状态！

僵尸进程的危害：

• 资源占用：占据进程表空间，使系统无法创建新进程；保留进程控制块，消耗内存。
• 性能下降：增加系统调度开销，干扰资源分配，影响正常进程运行。
• 管理混乱：干扰系统监控与调试，混淆系统信息，妨碍问题排查。

对于僵尸进程的解决方法，我们到进程等待的话题会给大家处理，现在大家只需要知道僵尸进程是怎么形成的以及它的危害

- 暂停状态（T，Stopped）

进程由于某种原因被暂停执行，比如收到了SIGSTOP信号、正在被调试等。暂停的进程不会占用 CPU资源，也不会继续执行，直到收到SIGCONT信号等恢复执行的信号才会继续运行。

int main()
{
    while(1)
    {
        printf("Hello World!
");
    }
    return 0;
}

我们可以在一个程序运行时，按下CTRL+Z，使其暂停，此时进程就处于暂停状态。

Hello World!
Hello World!
Hello World!^Z
[2]+  Stopped                 ./test
[zwy@iZbp1dkpw5hx2lyh7vjopaZ process]$ 

PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
10218 10261 10261 10218 pts/0    10261 S+    1000   0:08 ./test
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
10218 10261 10261 10218 pts/0    10218 T     1000   0:08 ./test
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
10218 10261 10261 10218 pts/0    10218 T     1000   0:08 ./test

可以看到进程进入了T状态，即暂停状态。

或者对进程发送信号，也会让其进入暂停状态。
使用kill -19 PID命令，可以让指定PID的进程进入T状态。

kill -19 11392

pid:11392
pid:11392
pid:11392

[2]+  Stopped                 ./test

- 追踪状态（t，tracing stop）

这是一种特殊的暂停状态，通常是因为进程正在被调试器等工具追踪。调试器可以通过系统调用对处于追踪状态的进程进行控制和观察，获取进程的运行信息、修改进程的状态等。

当我们使用cgdb对进程调试时，可以使进程进入t状态，例如：

[zwy@iZbp1dkpw5hx2lyh7vjopaZ process]$ gcc test.c -o test -g
[zwy@iZbp1dkpw5hx2lyh7vjopaZ process]$ cgdb test

PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
10218 12817 12817 10218 pts/0    12817 S+    1000   0:00 cgdb test
12817 12818 12818 12818 pts/3    12818 Ss+   1000   0:00 gdb --nw --annotate=2 -x /home/zwy/.tgdb/a2_gdb_init test
12818 13094 13094 13094 pts/4    13094 ts+   1000   0:00 /home/zwy/code/linux/process/test

其中我们使用cgdb调试的test进程就处于t状态，至于s状态则代表表明该进程是会话组长，+意味着该进程属于前台进程组，这个我们都不用关注，只需要了解使用调试器gdb或者cgdb调试程序时，进程会进入t状态。

本文小结

本文有关进程状态的话题到这里就结束了，后面的文章我们会展开讲解 进程的更多话题，进程优先级，进程的调度和切换，进程控制等等… 感谢您的观看！

如果你觉得这篇文章对你有所帮助，请为我的博客 点赞👍收藏⭐️ 评论💬或 分享🔗 支持一下！你的每一个支持都是我继续创作的动力✨！🙏
如果你有任何问题或想法，也欢迎 留言💬 交流，一起进步📚！❤️ 感谢你的阅读和支持🌟！🎉
祝各位大佬吃得饱🍖，睡得好🛌，日有所得📈，逐梦扬帆⛵！