Linux系统编程之回收子进程

已于 2022-05-16 14:47:09 修改
阅读量552 收藏 1
点赞数 1
分类专栏： Linux系统编程 文章标签： linux ubuntu bash
于 2022-05-02 22:17:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51029592/article/details/124529459
版权

回收子进程

孤儿进程

在这里插入图片描述

/*
 *  @file           orphan.c
 *  @brief          父进程比子进程先结束，子进程变成了孤儿进程，由init进程回收
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>

int main(void)
{
        pid_t pid;

        pid = fork();
        if (pid == 0)           //子进程
        {
                while(1)        //循环打印让父进程先结束，子进程变成孤儿进程
                {
                        printf("I am child,my parent pid = %d\n", getppid());
                        sleep(1);
                }
        }
        else if (pid > 0)       //父进程
        {
                printf("I am parent,my pid is %d\n", getpid());
                sleep(5);
                printf("-------parent going to die---------\n");
        }
        else if (pid == -1)     //创建子进程失败
        {
                perror("fork error");
                exit(1);
        }

        return 0;
}

刚开始的父进程是11872，后来父进程11872先结束了，子进程就变成孤儿进程了，父进程变成1了，即是init进程，由这个init进程进行子进程的回收
在这里插入图片描述

僵尸进程

在这里插入图片描述

/*
 *  @file           zoom.c
 *  @brief          子进程结束了，父进程也没有回收回收残留的资源，就变成僵尸进程了
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
        pid_t pid;

        pid = fork();
        if (pid == 0)           //子进程
        {
                printf("I am child, my parent %d, going to sleep 10s\n", getppid());
                sleep(10);
                printf("-----------child die-------------\n");
        }
        else if (pid > 0)       //父进程
        {
                while(1)        //子进程结束后，父进程并没有对子进程进行回收，导致子进程变成僵尸进程
                {
                        printf("I am parent, pid = %d,myson = %d\n", getpid(), pid);
                        sleep(1);
                }
        }
        else if (pid == -1)     //子进程创建失败
        {
                perror("fork error");
                exit(1);
        }

        return 0;
}

子进程结束了，父进程也没有回收回收残留的资源，就变成僵尸进程了在这里插入图片描述
这里看到的括号括起来的zoom就是僵尸态了在这里插入图片描述

wait函数

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
wait函数

在这里插入图片描述

用wait函数阻塞等待子进程结束，再由父进程粗略回收，但不知道子进程结束的状态

/*
 *  @file           zoom_wait.c
 *  @brief          用wait函数阻塞等待子进程结束，再由父进程粗略回收，但不知道子进程结束的状态
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
        pid_t pid;
        pid_t wpid;

        //创建一个子进程
        pid = fork();
        if (pid == 0)           //子进程
        {
                printf("I am child, my parent %d, going to sleep 10s\n", getppid());
                sleep(10);
                printf("-----------child die-------------\n");
        }
        else if (pid > 0)       //父进程
        {
                wpid = wait(NULL);              //阻塞等待子进程结束，回收子进程
                if(wpid == -1)                  //回收子进程失败
                {
                        perror("wait error");
                        exit(1);
                }
                while(1)                        //这里子进程已经被回收，弄一个while，方便去查看是否还有僵尸进程
                {
                        printf("I am parent, pid = %d,myson = %d\n", getpid(), pid);
                        sleep(1);
                }
        }
        else if (pid == -1)     //创建子进程失败
        {
                perror("fork error");
                exit(1);
        }

        return 0;
}

在这里插入图片描述
这样子父进程就可以回收到子进程了，就不会留下子进程的残留了
在这里插入图片描述

用wait函数阻塞等待子进程结束，再执行父进程，这里精确回收，得到了子进程结束的状态，子进程正常结束

/*
 *  @file           wait1.c
 *  @brief          用wait函数阻塞等待子进程结束，再执行父进程，这里精确回收，得到了子进程结束的状态，子进程正常结束
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
        pid_t pid;
        pid_t wpid;
        int status;

        //创建一个子进程
        pid = fork();
        if (pid == 0)           //子进程
        {
                printf("I am child, my parent %d, going to sleep 10s\n", getppid());
                sleep(10);
                printf("-----------child die-------------\n");
                exit(76);       //进程正常结束
        }
        else if (pid > 0)       //父进程
        {
                wpid = wait(&status);           //阻塞等待子进程结束，回收子进程
                if (wpid == -1)                 //回收子进程失败
                {
                        perror("wait error");
                        exit(1);
                }
                if (WIFEXITED(status))          //子进程正常结束
                {
                        printf("child exit with %d\n", WEXITSTATUS(status));            //打印输出exit的参数
                }
                while(1)        //这里子进程已经被回收，弄一个while，方便去查看是否还有僵尸进程
                {
                        printf("I am parent, pid = %d,myson = %d\n", getpid(), pid);
                        sleep(1);
                }
        }
        else if (pid == -1)     //创建子进程失败
        {
                perror("fork error");
                exit(1);
        }

        return 0;
}

在这里插入图片描述
用wait函数阻塞等待子进程结束，再执行父进程，这里精确回收，得到了子进程结束的状态，子进程异常结束

/*
 *  @file           wait2.c
 *  @brief          用wait函数阻塞等待子进程结束，再执行父进程，这里精确回收，得到了子进程结束的状态，子进程异常结束
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
        pid_t pid;
        pid_t wpid;
        int status;

      	//创建一个子进程
        pid = fork();
        if (pid == 0)           //子进程
        {
                printf("I am child, my parent %d, going to sleep 10s\n", getppid());
                sleep(60);              //这里阻塞60s，留着去kill子进程
                printf("-----------child die-------------\n");
                exit(76);
        }
        else if (pid > 0)       //父进程
        {
                wpid = wait(&status);           //阻塞等待子进程结束，回收子进程
                if (wpid == -1)                 //回收子进程失败
                {
                        perror("wait error");
                        exit(1);
                }
                if (WIFEXITED(status))          //子进程正常结束
                {
                        printf("child exit with %d\n", WEXITSTATUS(status));
                }
                if (WIFSIGNALED(status))        //子进程异常结束
                {
                        printf("child killed by %d\n", WTERMSIG(status));
                }
                while (1)
                {
                        printf("I am parent, pid = %d,myson = %d\n", getpid(), pid);
                        sleep(1);
                }
        }
        else if (pid == -1)     //创建子进程失败
        {
                perror("fork error");
                exit(1);
        }

        return 0;
}

这里用kill杀死子进程
在这里插入图片描述
wait函数得到了子进程结束的状态
在这里插入图片描述
在这里插入图片描述
回收多个子进程
上面已经用过wait函数来回收一个子进程，现在用wait函数来回收多个子进程

/*
 *  @file           wait3.c
 *  @brief          用wait函数来回收多个子进程
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(void)
{
        int i;
        pid_t pid;

        //创建5个子进程
        for (i = 0; i < 5; i++)
        {
                pid = fork();
                if (pid == 0)           //父进程继续循环，直到循环结束，子进程退出循环
                {
                        break;
                }
        }

        //判断是父进程还是子进程
        if(i < 5)
        {
                sleep(i);
                printf("I am %d child, pid = %u\n", i+1, getpid());
        }
        else
        {
                sleep(i);
                printf("I am parent\n");
                while (wait(NULL));             //循环回收多个子进程
        }

        return 0;
}

在这里插入图片描述

waitpid函数

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

用waitpid函数回收指定子进程
waitpid函数的第三个参数为0是阻塞回收，跟wait函数一样

/*
 *  @file           waitpid1.c
 *  @brief          用waitpid函数回收指定子进程
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(void)
{
        int i;
        pid_t pid;
        pid_t p;

        //循环创建5个子进程
        for (i = 0; i < 5; i++)
        {
                pid = fork();
                if (pid == 0)
                {
                        break;
                }
                else if (i == 3)
                {
                        p = pid;
                }
        }

        if (i < 5)
        {
                sleep(i);
                printf("I am %d child, pid = %u\n", i+1, getpid());
        }
        else
        {
                sleep(i);
                printf("I am parent\n");
                waitpid(p, NULL, 0);            //阻塞等待回收指定的子进程
                while (1);
        }

        return 0;
}

可以看出指定回收的第四个子进程已经被回收了
在这里插入图片描述
用waitpid函数回收多个子进程

/*
 *  @file           waitpid2.c
 *  @brief          用waitpid函数回收多个子进程
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(void)
{
        int i;
        pid_t pid;

        //循环创建5个子进程
        for (i = 0; i < 5; i++)
        {
                pid = fork();
                if (pid == 0)
                {
                        break;
                }
        }

        if (i < 5)
        {
                sleep(i);
                printf("I am %d child, pid = %u\n", i+1, getpid());
        }
        else
        {
                sleep(i);
                printf("I am parent\n");
                while (waitpid(-1, NULL, 0));           //等价于while(wait(NULL));
        }

        return 0;
}

可以看到所有子进程都被回收了
在这里插入图片描述
当waitpid函数的第三个参数为WNOHANG，为轮询回收子进程，子进程正在运行的时候，返回值为0
轮询回收多个子进程

/*
 *  @file           waitpid3.c
 *  @brief          用waitpid函数轮询回收多个子进程
 *  @version 1.1    无
 *  @author         北豼
 *  @date           2022年5月9日
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(void)
{
        int i;
        int n = 5;
        pid_t pid;
        pid_t wpid;

        //循环创建5个子进程
        for (i = 0; i < 5; i++)
        {
                pid = fork();
                if (pid == 0)
                {
                        break;
                }
        }

        if (i < 5)
        {
                sleep(i);
                printf("I am %d child, pid = %u\n", i+1, getpid());
        }
        else
        {
                sleep(i);
                printf("I am parent\n");
                do
                {
                        wpid = waitpid(-1, NULL, WNOHANG);              //轮询回收子进程
                        if (wpid > 0)
                        {
                                n--;
                        }
                        sleep(1);
                }while (n > 0);

                while (1);
        }

        return 0;
}

子进程已全部回收
在这里插入图片描述

是北豼不太皮吖
关注
专栏目录
linux操作系统之进程 子进程回收
小白杨的博客
04-18 1018
回收子进程主要有两个函数：wait(),waitpid()。 一个进程在终止时会关闭所有文件描述符，释放在用户空间分配的内存，但它的PCB还保留着，内核在其中保存了一些信息：如果是正常终止则保存着退出状态，如果是异常终止则保存着导致该进程终止的信号是哪个。这个进程的父进程可以调用wait或waitpid获取这些信息，然后彻底清除掉这个进程。我们知道一个进程的退出状态可以在Shell中用特殊变量$...
linux进程怎么被回收的,linux 多进程并发服务__关于子进程回收的方法
weixin_31486383的博客
05-05 190
以TCPServ 服务程序来说：１)父进程:负责系统初始化，以及监听(listen),接受连接请求(accept);其中accept 默认阻塞调用。２)每接受一个连接请求，动态新建(fork)一个子进程，任务完成或客户端断开，服务子进程需要退出并收回系统资源。３)根据linux的设计子进程的收回需要父进程参与(wait调用)，而此时附进程主要服务工作在监听客户端连接请求，同时阻塞在(accept)...
Linux之回收子进程
qq_41033011的博客
07-23 554
回收子进程 孤儿进程 父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为 init 进程，称为 init进程(进程ID为1)领养孤儿进程 【验证孤儿进程】 #include <stdio.h> #include <unistd.h> int main() { pid_t pid; pid = fork(); if(pid < 0) { perror("fork error\n"); return -1; } else if(pid > 0
Linux回收子进程
usstmiracle的博客
07-17 266
孤儿进程 孤儿进程: 父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为init进程，称为init进程领养孤儿进程。 #include <stdio.h> #include <unistd.h> #include <sys/wait.h> int main(void) { pid_t pid; pid = fork(); if (pid == 0) { while (1) { print
Linux——子进程回收
一个小孩
03-18 549
exec函数族 fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用exec并不创建新进程，所以调用exec前后该进程的id并未改变。 将当前进程的.text、.data替...
linux系统编程笔记docx.docx
05-12
### Linux系统编程核心知识点 #### 一、计算机系统组成与硬件结构 - **计算机系统硬件组成**： - **CPU**：中央处理器，包括运算器和控制器，负责指令的执行和控制系统的运行。 - **内存**：用于暂时存储运行中...
《Linux系统编程、网络编程》第5章 进程控制
06-12
课程内容：进程与程序、进程PID与三个特殊进程、fork函数的作用、父子进程对文件的共享、execve加载函数、system函数、进程的资源回收、wait函数、进程状态、java进程、进程关系、守护进程，return/exit/_exit、环境...
linux系统编程试卷(答案).pdf
09-30
由于给定的【部分内容】信息非常片段且杂乱，包含了大量不明代码和不连贯的说明，我们可以从中提炼和解释一些Linux系统编程相关知识点，但请注意，由于资料的不完整性，以下解释可能不连贯，亦可能无法提供完整的...
【嵌入式软件工程师面经】Linux系统编程（线程进程）.pdf
最新发布
04-27
### 嵌入式软件工程师面经：Linux系统编程（线程进程） #### 一、线程与进程的区别 1. **定义**： - **进程**：是系统中的一个可执行程序的一次运行实例，它是系统进行资源分配和调度的基本单位。 - **线程**：...
Linux系统编程学习笔记
02-07
### Linux系统编程学习笔记 #### 一、IO **1.1 标准I/O (stdio)** - **fopen/fclose**: `fopen` 用于打开或创建一个文件，并返回一个指向该文件的 `FILE *` 类型的指针。`fclose` 用于关闭由 `FILE *` 指向的文件...
Linux 进程回收
qq_40944811的博客
03-16 297
wait
Linux系统【三】回收子进程
T_T233333333的博客
03-26 287
孤儿进程 父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为init进程，则称init进程领养孤儿进程。 系统中有两个init进程，一个是root用户的，一个是当前用户的，root用户的init进程编号一般是１ 僵尸进程 进程终止，父进程不进行回收，自己成残留资源(PCB)存放在内核中，变成僵尸进程。 子进程死亡以后会将自己占用的内存（4G）释放，但是会将死亡信息放在自己的PCB中，希...
Linux进程控制３－子进程回收
KHY666的博客
11-05 265
Linux进程控制
Linux—进程、线程和进程通信（3）—进程的回收
weixin_73680102的博客
06-21 367
简要介绍进程回收、以及如何获取子进程返回值
wai函数用法 回收多个子进程（Linux系统编程）
qq_24447809的博客
09-04 230
回收单个子进程 #include<stdio.h> #include<stdlib.h> #include<unistd.h> #include<fcntl.h> #include<sys/types.h> #include<sys/wait.h> int main() { pid_t pid,wpid; int statu; pid=fork(); if(pid==0) //子进程 {
Linux进程相关函数（二）—回收子进程
LIUXIANGJY的博客
12-10 884
我们先来了解两个概念，什么是孤儿进程，以及什么是僵尸进程？ 孤儿进程 父进程先于子进程结束，此时子进程将将变成孤儿进程，孤儿进程会被init进程收留，init进程。 僵尸进程 子进程结束，父进程尚未回收子进程的状态，此时子进程将变成僵尸进程，其PCB进程块会残留在内核当中。 目录 回收子进程退出信息 DEMO 回收子进程退出信息 —wait函数 pid_t wait(int *wstatus); ...
linux系统进程 回收单个子进程——wait
m0_59008960的博客
03-21 170
1 /* 2 ##wait()函数头文件:#include<sys/types.h> #include<wait.h> 3 ##原型：pid_t wait(int * status); 4 父进程调用wait（）函数，可以回收子进程终止信息 5 1.阻塞等待子进程退出 6 2.回收子进程残留资源 7 3.获取子进程结束状态（退出原因） 8 wait()与fork()配套出现，若wait错误则返回-1,成功则返回子进程的pid 9 wait(NUL...
Linux编程--进程的创建和回收
xinqi_1的博客
06-12 149
存放在磁盘上的指令和数据的有序集合（文件）静态的。
linux 进程回收
weixin_59349642的博客
04-24 723
目录回顾一 进程回收wait函数 和函数解释1 回收子进程2 判断是否为异常退出3 杀死子进程返回的编号（补充） 回顾 1 父进程退出之后 会产生孤儿进程 并且会被养父进程收养 （int 类型的 ） 2 父进程一直在工作 没有收到子进程的信息 这时子进程就变成了僵尸进程 退出之后 才能收到子进程信息 继续往下学 一 进程回收wait函数 和函数解释 1 阻塞和等待就是一个概念 2 回收必须是父进程进行 3 获取结束的结束状态（退出原因） 是异常退出 还是正常退出 2 3点 我们 结合代
Linux系统编程：基于栈的内存分配解析
"基于栈的分配-“智慧高速云大脑”整体解决方案" 在计算机科学中，内存管理是程序设计中的一个重要方面，特别是在操作系统如...在Linux系统编程中，理解并正确使用内存分配策略对于编写高效且健壮的程序至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

是北豼不太皮吖

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值