【Linux进程篇】父子进程fork函数||进程生死轮回状态||僵尸进程与孤儿进程

最新推荐文章于 2024-07-17 22:26:53 发布

W…Y

最新推荐文章于 2024-07-17 22:26:53 发布

阅读量1.1k

点赞数 19

分类专栏： Linux 文章标签： linux 运维服务器 centos c++ 数据结构 ai

本文链接：https://blog.csdn.net/m0_74755811/article/details/139214684

版权

Linux 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

W...Y的主页 😊

代码仓库分享💕

前言：上篇文章中我们认识了进程，可执行程序在内存中加载运行被称作进程，而操作系统是通过给每一个可执行程序创建一个PCB来管理进程的。并且学习了一些查看进程的指令，认识了进程中的PID与PPID分别代表一个进程的唯一标识ID与他的父进程的ID，今天我们继续了解进程中的属性，探索其中的规则。

通过系统调用创建进程-fork初识

当我们执行一个可执行文件时，就相当于创建了一个进程，我们也可以在一个可执行程序中进行创建一个进程。通过对fork函数的理解，我们就可以实现。

我们可以在Linux下使用man fork来查看其中的内容：

#include<stdio.h>
  2 #include<unistd.h>
  3 
  4 int main()
  5 {
  6    printf("before fork: I am a prcess, pid: %d, ppid: %d\n", getpid(), getppid());
  7    fork();
  8    printf("after fork: I am a prcess, pid: %d, ppid: %d\n", getpid(), getppid());                                                                    
  9    return 0;
 10 }

我们创建一个可执行程序后使用fork来运行，我们可以看到：

在fork直线printf只打印一遍，而fork之后却打印了两遍。说明在fork之前只有一个执行分支，而fork之后就有两个执行分支，因为创建了子进程。我们通过打印的结果看来after fork中第三行的ppid是第二行的pid，说明fork创建了自己的子进程。fork之后代码共享！！！

fork有自己的返回值，pid_t：

如果fork成功父进程返回子进程的pid，子进程返回0。我们知道返回值后就可以操作父子进程，各做各的事情了，我们让其死循环打印，每隔一秒打印一次：

int main()
 14 {
 15   pid_t id = fork();
 16   if(id == 0)
 17   {
 18     //子进程
 19     while(1)
 20     {
 21       printf("child fork : I am process, pid: %d, ppid: %d\n", getpid(), getppid());
 22       sleep(1);
 23     }
 24   }
 25   else{
 26     //父进程
 27     while(1)
 28     {
 29       printf("parent fork : I am process, pid: %d, ppid: %d\n", getpid(), getppid());
 30       sleep(1);                                                                                                                                      
 31     }
 32   }
 33   return 0;
 34 }

以前在vs中写代码时，当程序进入死循环后不可能继续出来到下一个死循环中去，而在父子进程下却可以两个死循环同时进行！！！

操作系统会在创建好的可执行程序后构建一个task_struct，子进程也会创建一个task_struct，但是子进程会指向父进程的代码块与数据区中，共享同一块数据！！！父进程会将自己的task_struct中的大部分属性拷贝给子进程，所以子进程才能和父进程使用同一块数据与代码。

那很多人就会有疑问，为什么fork函数有两个返回值，一般函数不是只有一个吗？那如果一个函数已经到了return的时候，这个函数的整体逻辑已经完成了，所以我们可以理解为在返回之前就已经有父子两个进程了，所以就会有两个返回值。

父子进程代码共享，数据各自开辟空间，私有一份（采用写时拷贝）这个我们后面会讲。

我们如何创建多个进程呢？

#include<sys/types.h>
 38 const int num = 10;
 39 
 40 void Worker()
 41 {
 42     int cnt = 12;
 43     while(cnt)
 44     {
 45         printf("child %d is rnning, cnt: %d\n", getpid(), cnt);
 46         cnt--;
 47         sleep(1);
 48     }
 49 }             
 50                  
 51 int main()                                                                                              
 52 {
 53     for(int i = 0; i < num ;i++)
 54     {     
 55         pid_t id = fork();
 56         if(id < 0) break;       
 57         if(id == 0){
 58             //子进程      
 59             Worker();    
 60             exit(0); // C用过, 让子进程直接退出
 61         }           
 62         printf("father create child process success, child pid: %d\n", id);
 63         sleep(1);                              
 64     }    
 65                                                                            
 66     //只有父进程会执行到这里！
 67     sleep(15);
 68 
 69     return 0;
 70 }

我们使用循环创建了10个子进程，上述就是代码。

进程状态

进程排队

说到进程状态，我们先来说一说进程排队的事情。进程 = task_struct + 可执行程序。我们再Windows中使用软件时，当一个软件崩溃后不会影响其他软件，说明进程是一个个独立的，当我们写一个死循环程序时，别的程序也可以正常运行，证明进程不是一直在运行的，即使在CPU中也一样。因为计算机中有个时间片的概念，比如时间片规定为1ms，当一个程序在CPU上已经运行了1ms后就会被剥离下来，让后面的程序占用CPU，这就是为什么死循环也不会影响其他程序！！！

当我们运行这个程序时，在scanf时就需要我们键盘输入，但是我们不输入时就会一直等待。所以通过这个用例我们就可以知道在等待某种资源。

进程的排队其实不是程序排队，而是对应的task_struct在排队。并且task_struct的管理是用数据结构进行管理的，但是最奇特的是它可以插入多种数据结构。

在task_struct中存放了多个结构体，结构体里面有两个指针，一个指针指向下一个结构体首，一个指针指向上一个结构体。这样只要task_struct中有多个结构体，我们就可以使用多种数据结构进行匹配。

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）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态。

我们看源码可知，所谓的状态本质就是一个整形变量，类似与#define定义。而这些状态就是Linux中多个进程的后续动作，在进程排队时我们就需要这些状态来区分进程。

运行状态

只要这个程序万无一失，准备就绪，然后他们的PCB就开始在cpu进行排队，我们把这种进程叫做R运行状态。

阻塞状态

什么是阻塞状态呢？

当我们需要输入时，就必须要键盘输入。但是这些硬件都是被操作系统管理起来的。这些硬件管理就犹如cpu管理软件时创建的PCB一样。这些软件也有对应的结构体并且将他们连接起来，这样操作系统才可以更好的维护增删查改。当一个程序需要一款硬件时，其就会从运行状态转变为阻塞状态，并且将自己的PCB与硬件的结构体进行排队连接。

总结：当我们的进程等待某种硬件资源时，资源如果没有准备就绪，我们的进程的task_struct只能先将自己设置为阻塞状态，然后将自己的PCB连入等待的硬件资源队列中。状态的变迁引起的是PCB会被操作系统变迁到不同对列中去！！！

挂起状态

挂起状态必须要有一个大前提，就是计算机的资源已经非常小了，内存不够了，这时我们的某些进程（比如阻塞的进程，因为这些进程当前不会被cpu调用）为了腾出内存就出现了挂起状态。

当资源被挂起就会将进程的代码以及数据拷贝到磁盘的swap分区中，这个过程我们称作唤出。而当cpu要进行调度此进程时，在从磁盘中将代码与数据拷贝到内存中，这个过程叫做唤入。

各个状态的情况

当我们写入一个死循环：

这时这个程序一直在循环执行这个程序，但是我们通过监视可以看出这个进程的状态为S+。证明这个进程为睡眠状态，因为cpu的执行速度非常的快，我们基本捕捉不到这个进程的运行状态，并且这个程序我们是要往显示器上打印数据，cpu的速度远远高于显示器，所以我们看不到。但是当我们在程序中有一个空语句的循环时，我们就可以看到此进程一直是R+状态。

那后面的+是什么呢？+代表的是前端进程，而没有+代表的是后端进程。当有+时我们的显示器只能用来显示此进程，但是当没有+时，我们既可以看到进程显示的内容，而且可以执行我们的Linux命令。但是前端进程使用ctrl+c是可以终止的，但是后端进程只能使用kill -9 + pid才可以终止！！！

Linux默认执行程序时是前端进程，若想成为后端进程：./可执行程序 + &。

那我们说的S睡眠状态就是阻塞状态也是可中断睡眠状态。还有一个D状态叫做深度睡眠状态，也叫不可中断睡眠，就是操作系统不能将其终止。

我们可以使用kill -l指令查看我们可以对进程发送的信号：

其中我们最常用的指令信号就是kill -9 + PID，杀死当前进程。而kill -19 + PID就可以使进程状态为T状态，也就是暂停状态：

我们就可以将S状态转变为T状态。要想在恢复到运行的状态：kill -18 + PID即可。

Z(zombie)-僵尸进程

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

创建一个有僵尸进程的例子：

我们先创造一个父子进程，然后在五秒后exit(0)直接退出子进程，但是我们使用wait函数来读取子进程的信息，所以子进程就会由S+变为Z+成为僵尸进程。

僵尸进程危害

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