五、进程状态

5.1 普遍操作系统层面的进程状态（宏观）

5.1.1 什么叫做运行状态

5.1.2 阻塞状态

5.1.2 挂起状态

5.2 Linux 的进程状态（具体）

5.2.1 Linux 内核进程状态源代码

5.2.2 Linux 进程状态查看

5.2.3 Linux 运行状态 R（running）

5.2.4 Linux 睡眠状态 S（sleeping）

5.2.5 Linux 磁盘休眠状态 D（Disk sleep）

5.2.6 Linux 停止状态 T（stopped）

5.2.7 Linux 追踪停止状态 t（tracing stop）

5.2.7 Linux 死亡状态 X（dead）

5.2.7 Linux 僵尸状态 Z（zombie）

六、Linux 下两种特殊进程（僵尸进程、孤儿进程）

6.1 僵尸进程

6.2 孤儿进程

五、进程状态

5.1 普遍操作系统层面的进程状态（宏观）

在普遍的操作系统中，我们所遇到的进程状态有：运行、新建、就绪、挂起、阻塞、停止、挂机、死亡...等等，但是我们并不懂它们（学了等于没学），因为这是操作系统层面的说法，它的理论放到哪个操作系统中都对。所以我们要学习一个具体的操作系统来理解进程状态，这里具体的操作系统是 Linux

进程这么多状态，本质都是未来满足不同的运行场景的

下面先解释普遍操作系统层面上进程状态的概念（宏观理解），再具体学习一个操作系统的进程状态（Linux）

5.1.1 什么叫做运行状态

常见的外设有键盘、显示器、网卡、磁盘...等，操作系统也要对这些外设进行管理。那操作系统怎么管理呢？答案是：先描述，再管理。所以，在操作系统内都包含了每一个硬件的 struct结构体，这里比如struct div_keybord...等，这些结构体都包含了该硬件的所有属性，这些属性可以找到驱动上该硬件的所有匹配的方法，然后操作系统可以对硬件进行各种操作。

根据冯诺依曼体系结构，所有的数据结构和内部属性数据都在内存当中，因为操作系统开机就被加载到了内存中。

假设磁盘中有一个 bin.exe 文件要运行，它先被加载到内存里，操作系统要对该进程进行管理，要管理就要先描述，这里PCB假设是 struct task_struct {}；这个进程想要在 CPU 上运行起来，就必须加入到运行队列（runqueue）中，这个运行队列是 CPU 为管理进程而产生的，是内核给 CPU 准备的。为什么进程运行要进行排队？因为 CPU 的资源是有限的。

这里假设只有单核的 CPU （一个CPU），不考虑多核的情况，一个 CPU 只有一个运行队列，进程想要运行就必须加入到运行队列中，这里的运行队列假设是 struct runqueue{}，这个运行队列包括了 struct task_struct* head 和其他属性。

让进程入队列，本质是：将该进程的 task_struct 结构体对象放入到运行队列中

注意：进队列排队的是 task_struct 结构体，并不是让可执行程序去排队，这个 task_struct 结构体包含了该进程的代码和所有属性，运行队列中有一个头指针 struct task_struct* head，head 指针指向第一个进程，第一个进行的属性中又包含了下一个进程的指针，保证可以链接到下一个进程，依次往后就可以找到所有进程。

举个栗子：比如你要找工作了，你是把你的简历投到公司的邮箱里，而不是把你自己投到邮箱里。公司有自己的简历池，假设有一万份简历，HR 对这些投递的简历进行排序，HR 觉得你的简历不错，通过简历池选出你进行面试，HR 再把你的简历扔给面试官。你的简历上有你的电话、姓名、邮箱...等等，通过这个简历里面的方法可以找到你这个人。这个面试官相当于 CPU，HR 就相当于操作系统的调度算法——运队列对，你的简历就相当于 PCB 结构体 task_struct。面试官拿到的是你的简历，简历上有你的全部数据和属性，通过简历上的属性可以找到你这个人，PCB 结构体 task_struct 也是如此，它有进程的全部数据和属性，通过该进程的属性可以找到该进程所对应的代码和数据等等。

结构图，帮助理解，结合上面的文字理解：

总所周知，CPU 虽然很笨，但是他很快，很快意味着 CPU 很快轮转一遍进程（进程切换再详谈），运行队列里的进程随时随刻都要准本好，让 CPU 随时调度运行，此时在运行队列里的一个个进程就叫做运行状态（run）

区分一个概念：一个进程正在 CPU 上运行，它一定是运行状态，但是一个进程没有在 CPU 上运行，但他已经在运行队列里面了，这个进程也是运行状态

理解状态：状态是进程的内部属性，进程的全部属性又在 PCB 结构体 task_struc 中，所以状态就是在 PCB 结构体里面，这个状态可以用整数 int 进行表示，比如 int（1：run 2：stop 3：dead ...），用整数表示一个具体的状态，整数是几，就意味着状态是什么。

5.1.2 阻塞状态

根据冯诺依曼体系结构，CPU 很快，但是外设（显示屏，磁盘，键盘...）相较于 CPU 是很慢的，而且这些外设也是只有少量的。进程或多或少都要访问这些外部设备，比如有十几个进程想要访问磁盘，但是磁盘被进程A 用着，进程B 和进程C 又来了，它们也要访问磁盘，还有进程D、E、F... 要访问磁盘，磁盘没有准备好，进程B后面的进程也只能进行等待

一个结论：不要只以为你的进程只会等待（占用）CPU 资源，你的进程也可能随时随地会访问外设资源

假设有十几个进程想要访问磁盘，磁盘该怎么办呢？操作系统对外设进行管理也是先描述再组织，操作系统里面有管理每个外设的结构体，每个外设的结构体都有一个等待队列，这些结构体可以对访问该外设的进程进行管理，假设等待队列为 task_struct* wait_queue

假如有一个进程A在 CPU 中运行要访问磁盘，因为访问磁盘的速度太慢了，CPU 不可能说要一直等到这个进程访问完磁盘才执行下一个进程，CPU 就把这个进程链入磁盘的等待队列中，然后 CPU 继续执行下一个进程。

把进程从运行状态里面拿出来，放入到外设的结构队列中，让该进程等待外设资源，此时该进程的状态就不能叫做运行状态了，该进程的状态叫做阻塞状态

这个过程也是对该进程的 PCB 结构体对象放到不同的队列中，并不是拿该进程的数据和代码

磁盘忙完了，发现进程A 在等待磁盘，此时磁盘是空闲的，磁盘就告诉操作系统，进程A可以运行了，然后操作系统就走进程A，把进程A的阻塞状态改为运行状态，然后放入 CPU 的运行队列里，进程A 就等待 CPU 运行

结论：所谓的进程不同的状态，本质是进程在不同的队列中，等待某种资源

所以，我们一般把等待 CPU 资源的进程的状态叫做运行状态，一般把等待外设资源的进程叫做阻塞状态

5.1.2 挂起状态

场景假设：假设大量的进程处于阻塞状态，这些进程都在等待某种资源资源，进程B 是这些进程里的一个进程，也是处于阻塞状态

在这个过程中，进程B 也短时间内不会被调度，也就是不会被 CPU执行，该进程的 代码和数据 短期内不会被使用。

假设此时的内存空间不够了，又有新的程序加载到内存里，操作系统最大的特点就是为我们节省内存空间。这时操作系统发现进程B 短时间内不会被调度，进程B 的代码和数据短时间内也不会被执行，内存空间却一直被你进程B 占用，操作系统说：这不是占着茅坑不拉屎吗？

这时操作系统就做了一件事，把进程B 的代码和数据暂时保存到磁盘中，为其他进程腾出内存空间，腾出的空间可以被其他进程使用

我们把一个进程的代码和数据暂时换出到磁盘的这个过程叫做该进程被挂起，该状态就是挂起状态

该进程B只是数据和代码被换出到磁盘，进程B 内存中的内核数据结构还存在，也就是 task_struct 依旧存在

我们将进程的相关数据，加载到内存或保存到磁盘，这个过程叫内存数据的换入换出

阻塞状态和挂起状态有什么区别？

答：阻塞不一定挂起，挂起一定阻塞

其他状态暂时不谈

----------------我是分割线---------------

5.2 Linux 的进程状态（具体）

5.2.1 Linux 内核进程状态源代码

为了弄明白正在运行的进程是什么意思，我们需要知道进程的不同状态。一个进程可以有几个状态（在Linux内核里，进程有时候也叫做任务）
这里我们具体谈一下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 */
};

LInux 的运行状态由一个指针数组构成，task_state_array[0] 就代表运行状态，其他也是如此。

Linux 状态总览图：

5.2.2 Linux 进程状态查看

Linux 操作系统当中我们可以通过 ps aux 或 ps axj 命令查看进程的状态

ps aux

ps axj

其他的下面详细解释

5.2.3 Linux 运行状态 R（running）

R运行状态（running）:并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列里

运行状态上面的遍操作系统层面的进程状态（宏观）已经谈过了，自己往上翻阅

接下来我们看一下一个具体运行状态

测试代码：

#include<stdio.h>    
    
int main()    
{    
    int a = 0;    
    while(1)    
    {    
        a += 2;                                                                                                                                                            
    }    
    return 0;    
}

以下代码可以寻找指定的进程

 ps axj | grep 进程名

比如我运行了 mytest，然后我进行查找，R 就是运行状态，+ 暂时不理会，后面详细解释，处于 R，说明没有访问任何的外设资源

通过以下命令可以显示进程头部信息，可以配合上面的使用

ps axj | head -1 && ps axj | grep 进程名

5.2.4 Linux 睡眠状态 S（sleeping）

S睡眠状态（sleeping):意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠（interruptible sleep））

测试代码：

#include<stdio.h>    
    
int main()    
{    
    int a = 0;    
    while(1)    
    {    
        a += 2;    
        printf("当前值为：%d\n", a);                                     
    }    
    return 0;    
}

运行并查看进程，当前进程状态处于 S，叫做睡眠状态，睡眠状态也是阻塞状态的一种。因为 printf 要访问显示器，显示器是外设的一种，外设有个特点就是相较于 CPU 比较慢，慢就要等待显示器就绪，等待就要花较长的时间。比如99% 的时间都在等待 IO就绪，只有 1% 的时间执行打印代码

5.2.5 Linux 磁盘休眠状态 D（Disk sleep）

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

上面的 S 状态也叫浅度睡眠，进程可以被杀掉，这里的 D 状态叫做深度睡眠，表示该进程不会被杀掉，即便是操作系统也不行，只有该进程自动醒来才可以恢复或者给机器断电

假设场景：进程A需要向磁盘写入 10万条用户数据，这些数据对用户很重要。进程A 访问磁盘，等待磁盘写入数据，进程A 等待磁盘返回一个结果，数据是否写入成功，此时进程A 处于休眠状态S；此时突然内存空间不足了，挂机也无法解决内存空间不足的问题，操作系统会自主杀掉一些进程（特别是内存资源不用的，比如进程A），操作系统就把进程A 给杀掉了；假设此时磁盘写入数据失败了，磁盘给进程A 返回结果，发现进程A 没有应答，磁盘只能把这些数据丢弃，然后磁盘继续为其他进程提供服务。结果，这重要的 10万条数据皆丢失了。

为了防止这种情况的发生，Linux 给进程设置了深度睡眠 (D) 状态，处于深度睡眠状态的进程既不能被用户杀掉，也不能被操作系统杀掉，只能通过断电，或者等待进程自己醒来

深度睡眠状态一般很难见到，一般在企业中做高并发或高IO的时候会遇到，这里就不演示了

注：一旦机器大量进程处于 D状态，说明机器已经处于崩溃的边缘了

5.2.6 Linux 停止状态 T（stopped）

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

之前介绍了 kill -9 信号，它用于杀掉进程，今天这里再介绍两个

查看所有信号

kill -l

今天介绍的两个信号为 18，19， 18信号是继续，19信号是暂停

测试代码：

#include<stdio.h>    
    
int main()    
{    
    int a = 0;    
    while(1)    
    {    
        a += 2;    
        printf("当前值为：%d\n", a);                                     
    }    
    return 0;    
}

进程运行了，给进程发送 19号信号（暂停）

kill -19 进程的PID

发送 19号信号后，发现进程被暂停了

再次查看进程的状态，状态处于 T

再给进程发送 18号信号（继续），进程又继续运行起来，这里的 +不见了，后面解释，这时候进程就无法用 [Ctrl]+c 杀掉了，只能用 9号信号杀掉进程

kill -18 进程的PID

T 状态也是阻塞状态的一种，但是有没有挂起完全不知道，这是由操作系统自己决定的

----------------我是分割线---------------

下面解释两个概念，前台进程和后台进程

稍微改了一下代码：

#include<stdio.h>    
#include<unistd.h>                                                       
    
int main()    
{    
    int a = 0;    
    while(1)    
    {    
        a += 2;    
        printf("当前值为：%d\n", a);    
        sleep(2);    
    }    
    return 0;    
}

程序运行可以被 [Ctrl]+c 杀掉

[Ctrl]+c 杀掉，再次查找这个进程已经没有了

前台进程：可以被 [Ctrl]+c 杀掉的进程，命令行在这个终端可以起作用，S+ 的 + 就是前台进程的意思

下面运行进程，并用19号信号暂停进程，然后再用 18号信号继续进程，这时候的 + 号不见了

左边的终端命令行依旧起作用，但是无法用 [Ctrl]+c 杀掉的进程

后台进程：无法被 [Ctrl]+c 杀掉的进程，命令行在这个终端也可以起作用

无法用 [Ctrl]+c 杀掉，只能用 9号信号杀掉该进程，再次查询该进程已经没有了

5.2.7 Linux 追踪停止状态 t（tracing stop）

追踪暂停状态t 是也是一种暂停状态，不过它是一种特殊暂停状态，表示该进程正在被追踪。比如在使用 gdb 调试打断点的时候，程序暂停下来的状态就是 t状态，测试如下：

5.2.7 Linux 死亡状态 X（dead）

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

死亡状态只是一个返回状态，当一个进程的退出信息被读取后，该进程所申请的资源就会立即被释放，该进程也一瞬间就不存在了，所以你几乎不会在任务列表当中看到死亡状态

5.2.7 Linux 僵尸状态 Z（zombie）

我们创建一个进程的目的是为了让其帮我们完成某种任务，而既然是完成任务，进程在结束前就应该返回任务执行的结果，供父进程或者操作系统读取；所以进程退出的时候，不能立即释放该进程的资源，该进程要保存一段时间，让父进程或操作系统读取该进程的执行结果（保存一段时间是对于CPU 而言）

僵尸状态Z 就是进程退出时，该进程的资源不能立即被释放，该进程要保留一段时间，等待父进程或操作系统读取该进程结果的过程就叫僵尸状态

比如，有一个人在跑步中倒下了，没有了呼吸，这个人已经退出这个世界了（进程退出），警察来到现场对首先这个人退出的原因进行调查（父进程或操作系统读取该进程的执行结果），而不是立即进行对这个人进行火葬（资源清理）

----------------我是分割线---------------

六、Linux 下两种特殊进程（僵尸进程、孤儿进程）

6.1 僵尸进程

处于僵尸状态的进程，我们就称之为僵尸进程

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

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

下面用例子测试僵尸进程

测试代码：

#include<stdio.h>    
#include<unistd.h>    
#include<stdlib.h>    
    
int main()    
{    
    int id = fork();    
    if(id == 0)    
    {    
        printf("child, pid=%d, ppid=%d\n", getpid(), getppid());    
        sleep(5);    
        exit(1);    
    }    
    else    
    {    
        while(1)    
        {    
    
        printf("parent, pid=%d, ppid=%d\n", getpid(), getppid());                                                                                                          
            sleep(2);    
        }    
    }    
    return 0;    
}

运行代码后，可以通过以下监控脚本查看

[fy@VM-4-14-centos d1]$ while :; do ps axj | head -1 && ps axj | grep mytest | grep -v grep;echo "######################";sleep 1;done

当子进程退出后，子进程的状态就变成了僵尸状态

僵尸进程危害

进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。可父进程如果一直不读取，子进程就一直处于Z状态
维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在 task_struct(PCB)中，换句话说， Z状态一直不退出， PCB一直都要维护
那一个父进程创建了很多子进程，就是不回收，就会造成内存资源的浪费。因为数据结对象本身就要占用内存，比如C中定义一个结构体变量（对象），是要在内存的某个位置进行开辟空间！
也会造成内存泄漏
如何避免僵尸进程，后面进程控制讲

这里只讲了僵尸状态是一个问题，没有谈怎么解决，后面进程控制谈解决

6.2 孤儿进程

前面子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态，该进程就为僵尸进程，如果反过来。父进程先退出，子进程还在执行，这是什么进程？

父进程先退出，子进程就称之为“孤儿进程”，孤儿进程会被1号 init进程领养，由 init进程回收，1号进程就是操作系统

下面用例子测试孤儿进程

测试代码：

#include<stdio.h>    
#include<unistd.h>    
#include<stdlib.h>    
    
int main()    
{    
    int id = fork();    
    if(id == 0)    
    {    
        while(1)    
        {    
            printf("child, pid=%d, ppid=%d\n", getpid(), getppid());    
            sleep(1);    
        }                                                                           
    }    
    else    
    {    
            printf("parent, pid=%d, ppid=%d\n", getpid(), getppid());    
            sleep(5);    
            exit(1);    
    }    
    return 0;    
}

观察代码运行结果，在父进程未退出时，子进程的PPID就是父进程的PID，而当父进程退出后，子进程的PPID就变成了1，即子进程被1号进程领养了。

这种现象是一定存在的，如果不对子进程进行领养，对应的僵尸进程便没有人能回收了。如果是前台进程创建子进程，如果子进程变孤儿了，子进程会自动变成后台进程