【Linux】进程状态
阿熊不会编程 2024-10-13 15:07:01 阅读 55
🌎进程状态【下】
文章目录：
进程状态
内核中的进程状态
运行状态和睡眠状态
运行状态
前后台进程
睡眠状态
其他状态
D状态
T状态
T(Stopped)状态
T(tracing stop)状态
X状态
僵尸状态
孤儿进程
总结
前言：
在Linux操作系统中，进程状态是一个重要而又复杂的话题。了解进程状态可以帮助我们更好地理解操作系统的运行机制。那么话不多说，开启我们今天的话题。
🚀内核中的进程状态
Linux内核给出进程状态的几个表述：
<code>/*
* 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))。
D磁盘休眠状态(Disk sleep)：有时候也叫不可中断睡眠状态(uninterruptible sleep)，在这个状态的进程通常会等待IO的结束。
T停止状态(stopped)： 可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。
X死亡状态(dead)：这个状态只是一个返回状态，你不会在任务列表里看到这个状态。
我们来一个一个认识这些 进程状态。
🚀运行状态和睡眠状态
✈️运行状态
我们随便写一个程序，并且打印其进程标识符：
1 #include<stdio.h>
2 #include<unistd.h>
3
4 int main()
5 {
6 while(1)
7 {
8 printf("I'm a process, id=%d\n", getpid());
9 sleep(1);
10 }
11 return 0;
12 }
~
再使用ps命令监控进程的运行状态，命令如下：
ps ajx | head -1 && ps ajx | grep myprocess#查看进程信息
我们发现跑起来的进程全部都是 S+(加号的作用后面再谈) 状态，也就是 睡眠状态，但是我们的程序在一直跑，哪来的睡眠状态？
仔细看代码，哦，原来是Sleep函数搞的鬼，CPU速度很快，而休眠一秒对CPU来说太久了，所以很难捕捉到进程的运行状态。那么我们把sleep函数注释掉：
尽管我们把sleep函数注释掉了，但是通过监控，我们发现进程状态还是 S+ 状态。其实还是 因为CPU的速度太快了，而我们的printf()函数需要调用外设刷新到显示器上，而CPU实在是太快了，外设每次刷新，CPU都已经执行了很多次了，所以我们依旧很难捕捉到进程的运行状态。
那么好，我直接把printf函数接注释掉，就单纯while死循环，这下总得显示运行状态了吧！
现在这个进程什么也不干，也不访问外设，所以这次我们就能检测出进程状态为运行状态了。
想必你也发现了，grep 进程也是运行状态，这是因为我们使用了grep命令一直在过滤，就像我们睁开眼就知道自己是清醒的一样。
✈️前后台进程
我们来解释一下为什么我们看到的进程状态是 S+ 或者 R+？在Linux中，存在着 前台进程 和 后台进程 之分。
我们在命令行运行起来的程序一般都为前台进程，前台进程的进程状态一般都会带 ‘+’ 号。后台进程 一般为后台独立运行的进程，一般不接收终端的输入。
前台进程只需要加上特殊符号，也可转化为后台进程，比如：
<code>./myprocess & #特殊符号，表示将进程后台运行。
这个时候，就将进程变为后台进程了，S+ 也变为了 S，但是这里又出现了一个问题，我们 Ctrl + C 终止不掉这个进程。
其实，后台进程是不能用 Ctrl + C 直接杀死的，我们需要使用 <code>kill -9 进程标识符来杀死进程：
✈️睡眠状态
我们来看一段之前写过的代码：
<code>#include<stdio.h>
int main()
{
int a = 0;
scanf("%d", &a);
return 0;
}
再使用上面的监控脚本来进行进程状态的查看：
这里我们运行程序，程序卡在了scanf处，右侧监视显示状态为 S+ ，说明此时处于休眠状态。这时程其实就是操作系统里的阻塞状态！
虽然S状态就是 操作系统里的阻塞状态，但是操作系统级别的阻塞状态可能不仅仅包含S状态。
我在运行程序的时候并没有执行输入操作，反而直接 Ctrl +C 操作杀死了这个进程，所以我们的S状态也被称为 可中断睡眠。
🚀其他状态
✈️D状态
D状态，英文叫做：Disk Sleep，即 深度睡眠，但是今天我们没有办法从Shell上演示，所以我就描述一下D状态的作用。
在还没有D状态的时候，如果一个进程在向磁盘中写入200M的数据，这时，进程将200M数据丢给磁盘，接下来就等待磁盘的信号。
但是这个时候操作系统可能会误判这个 “不作为” 的进程，便会将它杀死，这样以来前面写入的数据无进程接收也就作废了，这里仅仅是200M数据，如果更多呢？这一定是一个大问题，所以操作系统就引入了一种D状态，那么当进程再对磁盘进行写入的时候，OS再过来检查，发现是D状态，便不会出现误判的问题了。
由以上的例子，我们也大概了解了D状态的作用，那么现在又有新的疑问了，D状态是阻塞状态吗？
其实，上面进程等待硬件资源的过程也是阻塞过程，所以D状态也是阻塞状态！
✈️T状态
📚T(Stopped)状态
T状态（stop），也就是进程暂停的状态，可以通过发送 SIGSTOP 信号给进程来停止进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。
我们再执行我们的程序：
<code> 1 #include<stdio.h>
2 #include<unistd.h>
3
4 int main()
5 {
6 while(1)
7 {
8 printf("this is a process, id=%d\n", getpid());
9 sleep(1);
10 }
11 return 0;
12 }
我们还会使用到 kill 命令的其中一个信号：
之前我们使用9号信号来杀死进程，现在我们使用19号新号 sigstop，用来停止一个正在运行的进程：
此时进程的状态就变为了 T 状态。这个进程就被暂停了。
此时我们可以使用18号信号来继续被终止的进程执行。
但是我们发现，继续运行后的进程却变为了后台进程，所以我们只有通过 kill -9 来杀死这个进程。
📚T(tracing stop)状态
为了观察 t 状态，我们依旧使用下面的代码：
<code>#include<stdio.h>
int main()
{
int a = 0;
scanf("%d", &a);
return 0;
}
我们使用gdb调试工具进行调试，再第七行打了断点，再次r的时候我们就能从监控脚本看到我们进程的状态为t状态了。t状态就是 表示被调试器调停以便于追踪调试的作用。
其实 不论是T状态还是t状态，他们都是暂停等待某种资源，所以，他们也都属于阻塞状态！
✈️X状态
X状态很简单，一般X状态表示为进程正常退出的状态，进程退出都是瞬时的，所以这个状态很难给大家演示出来，只需要知道 X状态为进程正常退出状态即可。
🚀僵尸状态
进程状态中有一个特殊的状态——僵尸状态，为了方便理解我来举一个例子：
有一天，阿熊在网上看到了一双很想要的鞋，于是攒下生活费一口气买下了，在购买商品后，支付给商家钱款。
但商家收到后却没有做出相应的反应，也没有给你发货。此时，你的金钱已经离开了你的账户，但商品却没有交付，你陷入了一种僵尸状态，既没有完成交易，也无法继续购买其他商品。
这就好比进程终止，但其父进程还没有做出善后处理，导致进程成为了僵尸状态。只有当商家发货或者退款后，交易才算是彻底完成。
下面我们就举一个例子让大家认识一下僵尸状态：
<code> 1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<unistd.h>
4
5 int main()
6 {
7 pid_t id = fork();
8 if(id < 0)
9 {
10 perror("fork error!");
11 exit(-1);
12 }
13
14 if(id == 0)
15 {
16 //child
17 int cnt = 5;
18 while(cnt--)
19 {
20 printf("I'm child process, pid=%d, ppid=%d\n", getpid(), getppid());
21 sleep(1);
22 }
23exit(0);
24 }
25 while(1) //father
26 {
27 printf("I'm father process, pid=%d, ppid=%d\n", getpid(), getppid());
28 }
29
30 return 0;
31 }
我们从监控脚本可以看到，当子进程退出的时候，子进程接下来的状态就变为了Z状态，其中在出现Z的行，后面跟着 <defunct>，其实就是失效的意思。
所以为什么要有Z状态呢？
我们为什么要创建进程？是希望进程能给我们做一些事情，所以子进程必须得有结果和数据。 那什么是僵尸呢？进程已经退出，但是当前进程的状态需要自己维持住，供上层读取(一般是父进程)，所以必须处于Z状态！
为了验证子进程一定会处于Z状态，我们不妨做个实验：
<code> 1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<unistd.h>
4 #include<sys/wait.h>
5 #include<sys/types.h>
6
7 int main()
8 {
9 pid_t id = fork();
10 if(id < 0)
11 {
12 perror("fork error!");
13 exit(-1);
14 }
15
16 if(id == 0)
17 {
18 //child
19 int cnt = 5;
20 while(cnt)
21 {
22 printf("I'm child process, pid=%d, ppid=%d\n", getpid(), getppid());
23 sleep(1);
24 cnt--;
25 }
26 exit(0);
27 }
28 //father
29 int cnt = 10;
30 while(cnt)
31 {
32 printf("I'm father process, pid=%d, ppid=%d\n", getpid(), getppid());
33 sleep(1);
34 cnt --;
35 }
36 wait(NULL);
37 printf("child already reclaim!\n");
38 sleep(5);
39
40 return 0;
41 }
我们使用到了 wait 函数接口，我们简单来看一下：
此接口是 用来回收子进程退出后的数据和信息的接口，具体我们以后再谈。
我们发现，子进程退出后确实维持了一段时间的僵尸状态，后面被父进程回收。
但是如果父进程没有读取子进程的信息呢？
这个时候，僵尸状态的进程就会一直存在。task_struct 对象也一直存在，需要占据内存空间，这就造成了 内存泄漏！
🚀孤儿进程
进程中还有一种特殊进程——孤儿进程，就跟名字那样，没有父进程的进程，也就是只有子进程。
如果一个父进程结束了，而子进程还没结束，那么这个子进程必然会变成僵尸状态，如果很多进程都变成了这种状态，子进程越来越多，系统绝对会挂的。
我们来看看事实是否如此：
<code> 1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<unistd.h>
4 #include<sys/wait.h>
5 #include<sys/types.h>
6
7 int main()
8 {
9 pid_t id = fork();
10 if(id < 0)
11 {
12 perror("fork error!");
13 exit(-1);
14 }
15
16 if(id == 0)
17 {
18 //child
19 int cnt = 10;
20 while(cnt)
21 {
22 printf("I'm child process, pid=%d, ppid=%d\n", getpid(), getppid());
23 sleep(1);
24 cnt--;
25 }
26 exit(0);
27 }
28 //father
29 int cnt = 5;
30 while(cnt)
31 {
32 printf("I'm father process, pid=%d, ppid=%d\n", getpid(), getppid());
33 sleep(1);
34 cnt --;
35 }
36
37 return 0;
38 }
我们发现并没像我们预期的那样，子进程变为僵尸进程，而是变为了休眠状态，我们不妨查看这个进程的ppid：
我们发现其实这时候子进程的父进程依旧存在，并且父进程变为了bash!
其实，在Linux中，如果一个父进程创建了子进程，但是父进程要先比子进程退出，这时候 子进程会被1号进程(操作系统)托管。
相信细心的小伙伴也注意到了，我在杀死孤儿进程的时候使用了kill命令，其实这也就说明 当一个子进程变成孤儿的时候，也变成了后台进程。
📒✏️总结
CPU为了知晓下一步进程该做何调整，于是需要很多种的进程状态，常见状态无外乎 休眠，运行，深度睡眠，暂停，死亡，僵尸。 进程分为前台进程和后台进程，前台进程可以使用 Ctrl+C 杀死，但是后台进程需要使用 信号杀死，运行程序时可以 使用特殊符号变为后台进程。 僵尸进程会影响系统的效率，僵尸是因为 父进程没有接收子进程的资源数据，使得子进程成为僵尸。 父进程要比子进程先退出，则这个子进程就变为了孤儿进程，并且由 bash 托管。
创作不易，如果这篇文章能帮助到你，还望点个小小的赞呀~~
声明
本文内容仅代表作者观点，或转载于其他网站，本站不以此文作为商业用途
如有涉及侵权，请联系本站进行删除
转载本站原创文章，请注明来源及作者。