进程3.0——进程状态与僵尸进程、孤儿进程

进程状态

一个进程的生命周期可以划分为一组状态，这些状态刻画了整个进程。进程状态即体现一个进程的生命状态

一般来说，进程有五种状态：

• 创建状态：进程在创建时需要申请一个空白PCB，向其中填写控制和管理进程的信息，完成资源分配。如果创建工作无法完成，比如资源无法满足，就无法被调度运行，把此时进程所处状态称为创建状态

• 就绪状态：进程已经准备好，已分配到所需资源，只要分配到CPU就能够立即运行

• 执行状态：进程处于就绪状态被调度后，进程进入执行状态

• 阻塞状态：正在执行的进程由于某些事件（I/O请求，申请缓存区失败）而暂时无法运行，进程受到阻塞。在满足请求时进入就绪状态等待系统调用

• 终止状态：进程结束，或出现错误，或被系统终止，进入终止状态。无法再执行

这五种状态的转换如图：

上面所说的是一个概念性质的，而具体在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 */
};

这些状态的具体含义是：

• R运行状态（running）: 并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列
  里。
• S睡眠状态（sleeping): 意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠
  （interruptible sleep））。
• D磁盘休眠状态（Disk sleep）有时候也叫不可中断睡眠状态（uninterruptible sleep），在这个状态的
  进程通常会等待IO的结束。
• T停止状态（stopped）： 可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可
  以通过发送 SIGCONT 信号让进程继续运行。
• X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态。
• Z僵死状态（zombie）：下文具体了解

父进程与子进程

在学习接下来的内容之前，需要对父进程和子进程有一个清晰的认识

在Linux里，除了进程0（即PID=0的进程）以外的所有进程都是由其他进程使用系统调用fork创建的，这里调用fork创建新进程的进程即为父进程，而相对应的为其创建出的进程则为子进程，因而除了进程0以外的进程都只有一个父进程，但一个进程可以有多个子进程。

fork函数包含在unistd.h库中，其最主要的特点是，调用一次，返回两次，当父进程fork()创建子进程失败时，fork()返回-1，当父进程fork()创建子进程成功时，此时，父进程会返回子进程的pid，而子进程返回的是0。所以可以根据返回值的不同让父进程和子进程执行不同的代码

如上图所示，当fork()函数调用后，父进程中的变量pid赋值成子进程的pid(pid>0)，所以父进程会执行else里的代码，打印出"This is the parent"，而子进程的变量pid赋值成0，所以子进程执行if(pid == 0)里的代码，打印出"This is the child"

现在我们知道，在Linux中，正常情况下，子进程是通过父进程创建的，子进程再创建新的子进程。但是子进程的结束和父进程的运行是一个异步过程，即父进程永远无法预测子进程到底什么时候结束。当一个进程完成它的工作终止之后，它的父进程需要调用wait()或者waitpid()系统调用取得子进程的终止状态

知道了这些，我们再来了解两种特殊的进程

僵尸进程

当一个子进程结束运行（一般是调用exit、运行时发生致命错误或收到终止信号所导致）时，子进程的退出状态（返回值）会回报给操作系统，系统则以SIGCHLD信号将子进程被结束的事件告知父进程，此时子进程的进程控制块（PCB）仍驻留在内存中。一般来说，收到SIGCHLD后，父进程会使用wait系统调用以获取子进程的退出状态，然后内核就可以从内存中释放已结束的子进程的PCB；而如若父进程没有这么做的话，子进程的PCB就会一直驻留在内存中，也即成为僵尸进程

简单来说，当进程退出但是父进程并没有调用wait或waitpid获取子进程的状态信息时就会产生僵尸进程

上文中提到的进程的僵死状态Z(zombie)就是僵尸进程对应的状态

我们可以写一个程序来查看一下僵尸进程：

#include
#include
#include

int main(){
     
  printf("pid = %d\n",getpid());
  pid_t pid = fork();
  if(pid < 0){
     
    printf("fork error\n");
    return -1;
  }else if(pid == 0){
     
    //这段代码只有子进程能够运行到，因为在子进程中fork的返回值为0
    printf("This is the child!pid = %d\n",getpid());
    sleep(5);
    exit(0); //退出进程
  }else if(pid > 0){
     
    //这段代码只有父进程能运行到
    printf("This is the parent!pid = %d\n",getpid());
  }
  //当fork成功时下面的代码父子进程都会运行到
  while(1){
     
    printf("-------------pid = %d\n",getpid());
    sleep(1);
  }
  return 0;
}

程序的运行结果：

ubuntu@VM-0-7-ubuntu:~/c_practice$ ./zombie 
pid = 24816
This is the parent!pid = 24816
-------------pid = 24816
This is the child!pid = 24817
-------------pid = 24816
-------------pid = 24816
.....

在程序开始运行时立即查看进程：

(这里我分别运行了两次，分别使用ps -ef和ps -aux查看了进程状态，所以两次的进程PID是不同的)

ubuntu@VM-0-7-ubuntu:~$ ps -ef | grep -v grep | grep zombie
ubuntu   23797 15818  0 14:53 pts/0    00:00:00 ./zombie
ubuntu   23798 23797  0 14:53 pts/0    00:00:00 ./zombie

ubuntu@VM-0-7-ubuntu:~$ ps -aux | grep -v grep | grep zombie
ubuntu   24288  0.0  0.0   4352   648 pts/0    S+   14:56   0:00 ./zombie
ubuntu   24289  0.0  0.0   4352    80 pts/0    S+   14:56   0:00 ./zombie

在进程运行五秒后再次查看进程：

ubuntu@VM-0-7-ubuntu:~$ ps -ef | grep -v grep | grep zombie
ubuntu   23797 15818  0 14:53 pts/0    00:00:00 ./zombie
ubuntu   23798 23797  0 14:53 pts/0    00:00:00 [zombie] 

ubuntu@VM-0-7-ubuntu:~$ ps -aux | grep -v grep | grep zombie
ubuntu   24288  0.0  0.0   4352   648 pts/0    S+   14:56   0:00 ./zombie
ubuntu   24289  0.0  0.0      0     0 pts/0    Z+   14:56   0:00 [zombie] 

可以看出当进程运行五秒后，子进程状态变成Z，就是僵死状态，子进程就成了僵尸进程

其实，僵尸进程是有危害的。进程的退出状态必须被维持下去，因为它要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。可父进程如果一直不读取，那子进程就一直处于Z状态。维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在task_struct(PCB)中，换句话说，当一个进程一直处于Z状态，那么它的PCB也就一直都要被维护。因为PCB本身就是一个结构体会占用空间，僵尸进程也就会造成资源浪费，所以我们应该避免僵尸进程的产生

孤儿进程

孤儿进程则是指当一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。

来段代码：

#include
#include
#include
#include

int main(){
      
  pid_t pid;
  pid = fork();
  if(pid < 0){
       
    perror("fork error");
    exit(1);
  }
  if(pid == 0){
      
    printf("This is the child!\n");
    printf("pid = %d,ppid = %d\n",getpid(),getppid());//父进程退出前的pid和ppid
    sleep(5);
    printf("\npid = %d,ppid = %d\n",getpid(),getppid());//父进程退出后的pid和ppid
  }else{
       
    printf("This is the father!\n");
    sleep(1);
    printf("father process is exited!\n");
  }
  return 0;
}

运行结果：

ubuntu@VM-0-7-ubuntu:~/c_practice$ ./orphan 
This is the father!
This is the child!
pid = 2338,ppid = 2337
father process is exited!
ubuntu@VM-0-7-ubuntu:~/c_practice$ 
pid = 2338,ppid = 1

我们可以看到结果和我们预见的是一样的，孤儿进程在父进程退出后会被init进程领养，直到自己运行结束为止。这个程序很容易理解,先输出子进程的pid和父进程的pid，再然后子进程开始睡眠父进程退出，这时候子进程变成孤儿进程，再次输出时，该进程的父进程变为init

孤儿进程由于有init进程循环的wait()回收资源，因此并没有什么危害