进程等待(wait和wait函数)【Linux】

简介: 进程等待(wait和wait函数)【Linux】


进程等待的概念

  进程等待就是通过 wait/waitpid的方式,让父进程对子进程进行等待子进程退出并且将子进程进行资源回收的过程。

进程等待的必要性

 为什么要进行进程等待?

   1. 因为父子进程的执行顺序是不确定的,可能父进程会比子进程先一步退出,此时就会让子进程成为僵尸进程,子进程已经退出,但是依旧占用着内存空间,造成内存泄漏。

   2. 由于一般来说,子进程的出现是为了协助父进程完成一些任务,子进程就像是父进程的手下小兵一样,因此子进程完成父进程交给的任务,退出后也一定要给父进程一个答复(子进程是否完成,是否出现异常等)。

返回值:

成功返回被等待进程pid,失败返回-1。

参数:

输出型参数,获取子进程退出状态,不关心则可以设置成为NULL 3. 父进程通过进程等待的方式,回收退出的子进程的资源,获取子进程的退出信息(也就是2)。

进程等待的方法

wait函数

#include <sys/types.h>

#inlclude <sys/wait.h>

pid_t wait(int* status);

返回值:

成功返回被等待进程pid,失败返回-1。

参数:

输出型参数,获取子进程退出状态,不关心则可以设置成为NULL,之后和waitpid一起介绍。

 如何进行等待?

  1. 调用wait函数,进程等待子进程的退出。
  2. 当子进程退出后,会变成一个僵尸进程(短暂的存在不会造成什么影响),然后通过wait函数,进程状态从僵尸状态(Z)变成死亡状态(X)。
  3. 如果子进程没有退出,父进程必须阻塞等待,直到子进程变成Z,wait自动回收返回。
#include <iostream>
#include <unistd.h>
#include <sys/wait.h>
#include <cstdlib>
int main()
{
    pid_t fd = fork();
    if (fd == 0)
    {
        sleep(5);
        std::cout << "child: " << getpid() << std::endl;
        exit(0);
    }
    if (fd > 0)
    {
        sleep(1);
        std::cout << "parent: " << getpid() << std::endl;
    }
    sleep(50);
    return 0;
}

子进程退出后由于父进程没有等待回收,子进程变成僵尸进程:

调用wait后,子进程就会回收释放了:

#include <iostream>
#include <unistd.h>
#include <sys/wait.h>
#include <cstdlib>
int main()
{
    pid_t fd = fork();
    if (fd == 0)
    {
        sleep(5);
        std::cout << "child: " << getpid() << std::endl;
        exit(0);
    }
    if (fd > 0)
    {
        sleep(1);
        std::cout << "parent: " << getpid() << std::endl;
        wait(NULL);
    }
    sleep(50);
    return 0;
}

waitpid函数

#include <sys/types.h>

#inlclude <sys/wait.h>

pid_ t waitpid(pid_t pid, int *status, int options);

返回值:

  当正常返回的时候waitpid返回收集到的子进程的进程ID;

如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0;

  如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在;

参数:

 pid:

  Pid=-1,等待任一个子进程。与wait等效。

  Pid>0.等待其进程ID与pid相等的子进程。

 status:

  WIFEXITED(status): 若为正常终止子进程返回的状态,则为真。(查看进程是否是正常退出)

  WEXITSTATUS(status): 若WIFEXITED非零,提取子进程退出码。(查看进程的退出码)

 options:

  WNOHANG: 若pid指定的子进程没有结束,则waitpid()函数返回0,不予以等待。若正常结束,则返回该子进

程的ID。

  status其实就是个int型的输出型参数,一共32bit,但是我们只需要关注低位的16bit就行。下图是16bit, status的示意图:

使用方法:

  • 判断是否正常终止,可以提取低7位,如果全0就是正常终止:
    (status & 0x7F)
  • 提取退出状态:( (status >> 8) & 0xFF)
  • 提取终止状态:(status & 0x7F)
  • 提取core dump: ( (status >> 7) & 0x1)

除了使用上面的方法,也可以:

  • 判断是否正常终止:WIFEXITED(status);若为正常终止子进程返回的状态,则为真.
  • 提取子进程退出码:WEXITSTATUS(status); 若WIFEXITED非零,提取子进程退出码。(查看进程的退出码)
#include <iostream>
#include <unistd.h>
#include <sys/wait.h>
#include <cstdlib>
int main()
{
    pid_t fd = fork();
    if (fd == 0)
    {
        sleep(5);
        std::cout << "child: " << getpid() << std::endl;
        exit(8);
    }
    if (fd > 0)
    {
        int st;
        int ret = waitpid(fd, &st, 0);
        if (ret > 0 && (st & 0x7F) == 0)
        {
            std::cout << "退出状态:" << ((st >> 8) & 0xFF) << std::endl;
        }
        else if (ret > 0)
        {
            std::cout << "终止信号:" << (st & 0x7F) << std::endl;
        }
        std::cout << "parent: " << getpid() << std::endl;
    }
    return 0;
}

正常终止:

被kill杀死:上面的代码中子进程存在的时间延长

#include <iostream>
#include <unistd.h>
#include <sys/wait.h>
#include <cstdlib>
int main()
{
    pid_t fd = fork();
    if (fd == 0)
    {
        sleep(50);
        std::cout << "child: " << getpid() << std::endl;
        exit(8);
    }
    if (fd > 0)
    {
        int st;
        int ret = waitpid(fd, &st, 0);
        if (ret > 0 && (st & 0x7F) == 0)
        {
            std::cout << "退出状态:" << ((st >> 8) & 0xFF) << std::endl;
        }
        else if (ret > 0)
        {
            std::cout << "终止信号:" << (st & 0x7F) << std::endl;
        }
        std::cout << "parent: " << getpid() << std::endl;
    }
    return 0;
}

  验证时通过while :; do ps axj | head -1 && ps axj | grep test11 | grep -v "grep"; sleep 1; echo "###############"; done的指令来过去子进程的pid。

非阻塞等待和阻塞等待的对比

阻塞等待:

#include <iostream>
#include <unistd.h>
#include <sys/wait.h
> 这里是引用
#include <cstdlib>
int main()
{
    pid_t fd = fork();
    if (fd == 0)
    {
        sleep(10);
        std::cout << "child: " << getpid() << std::endl;
        exit(8);
    }
    if (fd > 0)
    {
        int ret;
        int st;
        do
        {
            ret = waitpid(fd, &st, 0);
            std::cout << "如果是非阻塞等待,则指向这个打印" << std::endl;
        } while (ret == 0);
        if (ret > 0 && (st & 0x7F) == 0)
        {
            std::cout << "退出状态:" << ((st >> 8) & 0xFF) << std::endl;
        }
        else if (ret > 0)
        {
            std::cout << "终止信号:" << (st & 0x7F) << std::endl;
        }
    }
    return 0;
}

  可以看到由于waitpid函数是这样的:waitpid(fd, &st, 0);option也就是第三个参数为0,表示阻塞等待,所以如果是非阻塞等待,则指向这个打印这句话只执行了一次。

非阻塞等待

  非阻塞等待也叫非阻塞轮询式等待,既然是轮询,就需要使用while循环的进行waitpid,否则如果waitpid没有等到子进程,就会执行下面的指令,直接执行完然后退出父进程。就不能回收子进程资源了。使用while时,需要注意这句话:如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0;

#include <iostream>
#include <unistd.h>
#include <sys/wait.h>
#include <cstdlib>
int main()
{
    pid_t fd = fork();
    if (fd == 0)
    {
        sleep(10);
        std::cout << "child: " << getpid() << std::endl;
        exit(8);
    }
    if (fd > 0)
    {
        int ret;
        int st;
        do
        {
            ret = waitpid(fd, &st, WNOHANG);
            std::cout << "如果是非阻塞等待,则指向这个打印" << std::endl;
        } while (ret == 0);
        if (ret > 0 && (st & 0x7F) == 0)
        {
            std::cout << "退出状态:" << ((st >> 8) & 0xFF) << std::endl;
        }
        else if (ret > 0)
        {
            std::cout << "终止信号:" << (st & 0x7F) << std::endl;
        }
    }
    return 0;
}

  可以看到由于waitpid函数是这样的:waitpid(fd, &st, WNOHANG);option也就是第三个参数为WNOHANG,表示非阻塞等待,所以如果是非阻塞等待,则指向这个打印这句话只执行了数次。


   😄 创作不易,你的点赞和关注都是对我莫大的鼓励,再次感谢您的观看😄

目录
打赏
0
0
0
0
12
分享
相关文章
【Linux进程概念】—— 操作系统中的“生命体”,计算机里的“多线程”
在计算机系统的底层架构中,操作系统肩负着资源管理与任务调度的重任。当我们启动各类应用程序时,其背后复杂的运作机制便悄然展开。程序,作为静态的指令集合,如何在系统中实现动态执行?本文带你一探究竟!
【Linux进程概念】—— 操作系统中的“生命体”,计算机里的“多线程”
Linux内核中的线程和进程实现详解
了解进程和线程如何工作,可以帮助我们更好地编写程序,充分利用多核CPU,实现并行计算,提高系统的响应速度和计算效能。记住,适当平衡进程和线程的使用,既要拥有独立空间的'兄弟',也需要在'家庭'中分享和并行的成员。对于这个世界,现在,你应该有一个全新的认识。
134 67
【YashanDB 知识库】如何避免 yasdb 进程被 Linux OOM Killer 杀掉
本文来自YashanDB官网,探讨Linux系统中OOM Killer对数据库服务器的影响及解决方法。当内存接近耗尽时,OOM Killer会杀死占用最多内存的进程,这可能导致数据库主进程被误杀。为避免此问题,可采取两种方法:一是在OS层面关闭OOM Killer,通过修改`/etc/sysctl.conf`文件并重启生效;二是豁免数据库进程,由数据库实例用户借助`sudo`权限调整`oom_score_adj`值。这些措施有助于保护数据库进程免受系统内存管理机制的影响。
【Linux】进程概念和进程状态
本文详细介绍了Linux系统中进程的核心概念与管理机制。从进程的定义出发,阐述了其作为操作系统资源管理的基本单位的重要性,并深入解析了task_struct结构体的内容及其在进程管理中的作用。同时,文章讲解了进程的基本操作(如获取PID、查看进程信息等)、父进程与子进程的关系(重点分析fork函数)、以及进程的三种主要状态(运行、阻塞、挂起)。此外,还探讨了Linux特有的进程状态表示和孤儿进程的处理方式。通过学习这些内容,读者可以更好地理解Linux进程的运行原理并优化系统性能。
65 4
【Linux】进程IO|系统调用|open|write|文件描述符fd|封装|理解一切皆文件
本文详细介绍了Linux中的进程IO与系统调用,包括 `open`、`write`、`read`和 `close`函数及其用法,解释了文件描述符(fd)的概念,并深入探讨了Linux中的“一切皆文件”思想。这种设计极大地简化了系统编程,使得处理不同类型的IO设备变得更加一致和简单。通过本文的学习,您应该能够更好地理解和应用Linux中的进程IO操作,提高系统编程的效率和能力。
130 34
|
3月前
|
linux中的目录操作函数
本文详细介绍了Linux系统编程中常用的目录操作函数,包括创建目录、删除目录、读取目录内容、遍历目录树以及获取和修改目录属性。这些函数是进行文件系统操作的基础,通过示例代码展示了其具体用法。希望本文能帮助您更好地理解和应用这些目录操作函数,提高系统编程的效率和能力。
206 26
|
2月前
|
Linux:守护进程(进程组、会话和守护进程)
守护进程在 Linux 系统中扮演着重要角色,通过后台执行关键任务和服务,确保系统的稳定运行。理解进程组和会话的概念,是正确创建和管理守护进程的基础。使用现代的 `systemd` 或传统的 `init.d` 方法,可以有效地管理守护进程,提升系统的可靠性和可维护性。希望本文能帮助读者深入理解并掌握 Linux 守护进程的相关知识。
76 7
|
2月前
|
Linux 进程前台后台切换与作业控制
进程前台/后台切换及作业控制简介: 在 Shell 中,启动的程序默认为前台进程,会占用终端直到执行完毕。例如,执行 `./shella.sh` 时,终端会被占用。为避免不便,可将命令放到后台运行,如 `./shella.sh &`,此时终端命令行立即返回,可继续输入其他命令。 常用作业控制命令: - `fg %1`:将后台作业切换到前台。 - `Ctrl + Z`:暂停前台作业并放到后台。 - `bg %1`:让暂停的后台作业继续执行。 - `kill %1`:终止后台作业。 优先级调整:
107 5
Linux 进程管理基础
Linux 进程是操作系统中运行程序的实例,彼此隔离以确保安全性和稳定性。常用命令查看和管理进程:`ps` 显示当前终端会话相关进程;`ps aux` 和 `ps -ef` 显示所有进程信息;`ps -u username` 查看特定用户进程;`ps -e | grep &lt;进程名&gt;` 查找特定进程;`ps -p &lt;PID&gt;` 查看指定 PID 的进程详情。终止进程可用 `kill &lt;PID&gt;` 或 `pkill &lt;进程名&gt;`,强制终止加 `-9` 选项。
44 3
c++ linux通过实现独立进程之间的通信和传递字符串 demo
的进程间通信机制,适用于父子进程之间的数据传输。希望本文能帮助您更好地理解和应用Linux管道,提升开发效率。 在实际开发中,除了管道,还可以根据具体需求选择消息队列、共享内存、套接字等其他进程间通信方
85 16
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等