五、进程状态

1.进程状态定义

一个进程从创建而产生至撤销而消亡的整个生命期间，有时占有处理器执行，有时虽可运行但分不到处理器、有时虽有空闲处理器但因等待某个事件的发生而无法执行，这说明进程和程序不相同，它是活动的且有状态变化的，能够体现一个进程的生命状态，可以用一组状态来描述：

内核源代码里面的状态定义：

1. /*
2. * The task state array is a strange "bitmap" of
3. * reasons to sleep. Thus "running" is zero, and
4. * you can test for combinations of others with
5. * simple bit tests.
6. */
7. static const char * const task_state_array[] = {//进程也叫做任务
8. "R (running)", /* 0 */
9. "S (sleeping)", /* 1 */
10. "D (disk sleep)", /* 2 */
11. "T (stopped)", /* 4 */
12. "t (tracing stop)", /* 8 */
13. "X (dead)", /* 16 */
14. "Z (zombie)", /* 32 */
15. };

通过不同状态来对进程进行区分，从而对进程进行分类。Linux进程的状态信息保存在进程的task_struct中。

2.进程状态分类

使用如下两条命令都可以查看进程当前状态：

ps aux

ps axj

查看到的进程状态：

（1）R-运行状态

R(Running)：要么在运行中，要么在运行队列里，所以R状态并不意味着进程一定在运行中，因此系统中可能同时存在多个R状态进程。

如下代码statusType.c:

1. #include<stdio.h>
2. int main()
3. {
4. while(1);
5. return 0;
6. }

运行起来之后，一直处于运行状态，会发现是R+ 状态，其中+表示在前台运行：

如果运行时在后面加&，就会在后台运行，就变成R状态了：

后台运行的进程只能用kill -9 进程号来杀掉了：

在运行状态的进程，是可以被CPU调度的，当操作系统切换进程时，就会直接在运行队列里选取R状态进程。

（2）S-浅睡眠状态

S(Sleeping) ：进程正在等待某事件完成，可以被唤醒，也可被杀死，浅睡眠状态也叫做可中断睡眠。

比如如下代码：

status.c

1. int main()
2. {
3. printf("hello linux\n");
4. sleep(20);
5. 
6. return 0;
7. }

在运行后20s内查看status进程的状态，发现为S+，执行kill命令后，该进程被杀死：

（3）D-深睡眠状态

D(Disk sleep)：进程正在等待IO，不能被杀死，必须自动唤醒才能恢复，也叫不可中断睡眠状态。

进程等待IO时，比如对磁盘写入，正在写入时，进程处于深度睡眠状态，需要等待磁盘将是否写入成功的信息返回给进程，因此此时进程不会被杀掉

（4）T-停止状态

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

运行起来的status进程，通过SIGSTOP信号被暂停了，状态由S+变为T：

又通过SIGCONT信号恢复了，状态由T变为S：

kill -l命令可列出操作系统中所有信号，其中18就是SIGCONT信号，19就是SIGSTOP信号：

因此上述kill SIGCONT 进程号也可以用kill -18 进程号来代替，kill SIGSTOP 进程号也可以写成kill -19 进程号来代替。

（5）Z-僵尸状态

当进程退出时，所占用的资源不是立即被释放，而是要暂时保存进程的所有退出信息来辨别进程死亡的原因(比如代码有问题、被操作系统杀死等)，这些数据都保存在task_struct中，供父进程或系统读取，这就是僵尸状态存在的原因。

当进程退出并且父进程没有读取到子进程退出的返回码时就会产生僵尸进程。僵尸进程会以终止状态保持在进程表中，并且会一直等待父进程读取退出状态码。

如下代码，statusZombie.cc：

1. #include<iostream>
2. #include<unistd.h>
3. using namespace std;
4. 
5. int main()
6. {
7. pid_t id = fork();
8. if(id == 0)
9.     {
10. while(1)
11.         {
12.             cout << "child is running" << endl;
13. sleep(20);
14.         }
15.     }
16. else
17.     {
18.         cout  << "father" << endl;
19. sleep(50);
20.     }
21. return 0;
22. }

Makefile:

1. statusZombie:statusZombie.cc
2.         g++ -o $@ $^
3. .PHONY:clean
4. clean:
5. rm -f statusZombie

使用如下监控进程脚本

while :; do ps axj | head -1 && ps ajx | grep 进程名 | grep -v grep;sleep 1;  echo "####################"; done

来监控进程状态，进程运行之后，父进程和子进程的状态变成了S：

杀掉子进程后，子进程的状态变成了Z状态：

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

（6）X-死亡状态

这个状态只是一个返回状态，在任务列表里看不到这个状态。因为当进程退出时，释放进程所占用的资源时一瞬间就释放完了，所以死亡状态看不到。

3.僵尸进程危害

从僵尸状态我们知道了僵尸进程退出时会等待父进程或系统读取其返回码来辨别进程死亡的原因。这就像我们在写代码时，main函数的返回值都是0:

1. #include<stdio.h>
2. int main()
3. {
4.  //code
5.  return 0;
6. }

返回值0就是为了告诉操作系统代码顺利执行结束，可以使用echo $?来获取进程最后一次退出时的退出码：

当子进程退出，而父进程还在运行，但是父进程没有读取子进程的退出信息，子进程就进入了僵尸状态。

如下面代码zombieProcess.c，子进程在打印5次之后退出，父进程没有读取子进程的退出信息，此时子进程就变成僵尸状态：

1. #include<stdio.h>
2. #include<stdlib.h>
3. #include<unistd.h>
4. int main()
5. {
6. pid_t id = fork();
7. if(id == 0)//child
8.     {
9. int count = 5;
10. while(count)
11.         {
12. printf("child PID:%d,PPID:%d,count:%d\n",getpid(),getppid(),count);
13. sleep(1);
14.             count--;
15.         }
16. printf("child is quiting\n");
17. exit(1);
18.     }
19. else if(id >0)//father
20.     {
21. while(1)
22.         {
23. printf("father PID:%d,PPID:%d\n",getpid(),getppid());
24. sleep(1);
25.         }
26.     }
27. else//fork error
28.     {
29. //do nothing
30.     }
31. return 0;
32. }

使用监控脚本就可以看到子进程的状态就变成了僵尸状态：

僵尸进程危害：

（1）进程的退出状态必须被维持下去，因为它要把退出信息告诉父进程，如果父进程一直不读取，那么子进程就一直处于僵尸状态

（2）由于进程基本信息是保存在task_struct中的，如果僵尸状态一直不退出，只要父进程没有读取子进程退出信息，那么PCB一直都需要维护。

（3）如果一个父进程创建了多个子进程，并且不回收，那么就要维护多个task_struct 数据结构，会造成内存资源的浪费

（4）僵尸进程申请的资源无法进行回收，那么僵尸进程越多，实际可用的资源就越少，也就是说，僵尸进程会导致内存泄漏

六、孤儿进程

僵尸进程是子进程先退出，但是父进程没有读取子进程的退出信息。

假如父进程先退出，子进程后退出，此时子进程处于僵尸状态，没有父进程来读取它的退出信息，此时子进程就称为孤儿进程。

如下代码orphanProcess.c，父进程在5秒后终止退出，子进程并没有退出：

1. #include<stdio.h>
2. #include<unistd.h>
3. #include<stdlib.h>
4. int main()
5. {
6. pid_t id = fork();
7. if(id ==0)//child
8.     {
9. while(1)
10.         {
11. printf("child\n");
12. sleep(2);
13.         }
14.     }
15. else//father
16.     {
17. sleep(5);
18.     printf("father is quiting\n");
19. exit(1);//父进程5秒后终止
20.     }
21. return 0;
22. }