【Linux进程篇】Linux中的等待机制与替换策略

最新推荐文章于 2024-08-09 10:53:56 发布

W…Y

最新推荐文章于 2024-08-09 10:53:56 发布

阅读量963

点赞数 14

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

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

版权

Linux 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

进程等待

进程等待必要性

之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。
另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。
最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。
父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

上篇博客中，我们讲到进程退出时有两个非常重要的信息：退出信号和退出码。当我们进程退出时退出信息会被放入进程的PCB中进行保存，等待父进程的回收。

因为进程拥有独立性，所以我们想通过参数或返回值将信息转交给父进程那是不可能的，所以我们才要进行回收资源。

进程等待的方法

wait方法

返回值：
成功返回被等待进程pid，失败返回-1。
参数：
输出型参数，获取子进程退出状态,不关心则可以设置成为NULL

下面是测试子进程变僵尸后wait是否进行回收资源：

我们可以看出父进程可以将僵尸进程回收！！！

waitpid方法

返回值：
当正常返回的时候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。

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

int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        // child
        int cnt = 5;
        while(cnt)
        {
            printf("Child is running, pid: %d, ppid: %d\n", getpid(), getppid());
            sleep(1);
            cnt--;
        }
        exit(1);
    }
    int status = 0;
    pid_t rid = waitpid(id, &status, 0); // 阻塞等待
    if(rid > 0)
    {
        printf("wait success, rid: %d, status: %d\n", rid, status);
    }

}

如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。
如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。
如果不存在该子进程，则立即出错返回。

获取子进程status

wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。
如果传递NULL，表示不关心子进程的退出状态信息。
否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）：

当我们的子进程exit(1)时，子进程的退出状态status为256。256代表什么呢？

任何进程最终执行状态我们可以使用两个数字具体表明情况

我们为了直观一点，可以使用位操作，将退出信号和退出码分别打印出来：

printf("wait success, rid: %d, status: %d, exit signo: %d, exit code: %d\n", rid, status, status&0x7F, (status >> 8)&0xFF);

我们也可以使用宏来获取退出信号与退出码：

int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        // child
        int cnt = 5;
        while(cnt)
        {
            printf("Child is running, pid: %d, ppid: %d\n", getpid(), getppid());
            sleep(1);
            cnt--;
        }
        exit(1);
    }
    int status = 0;
    pid_t rid = waitpid(id, &status, 0); // 阻塞等待
    if(WIFEXITED(status))
    {
        printf("wait success, rid: %d, status: %d, exit code: %d\n", rid, status, WEXITSTATUS(status));
    }

}

阻塞与非阻塞

在waitpid函数中，我们发现在上面的代码中，我们一直默认第三个参数为0。其就是对应的阻塞状态。而WNOHANG这个宏在第三个参数中可以进行填入，代表非阻塞等待。

阻塞等待时，父进程不能做任何事情，只能等待子进程变成僵尸进程后进行回收。而非阻塞等待可以轮转时进行行为。

非阻塞等待代码：

int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        // child
        int cnt = 5;
        while(cnt)
        {
            printf("Child is running, pid: %d, ppid: %d\n", getpid(), getppid());
            sleep(1);
            cnt--;
        }
        exit(1);
    }
    int status = 0;
    pid_t rid = waitpid(id, &status, WNOHANG); 
    while(1)
    {
        if(rid > 0)
        {
            printf("wait success, rid: %d, status: %d, exit code: %d\n", rid, status, WEXITSTATUS(status));
            break;
        }
        else if(rid == 0)
        {
            printf("father say: child is running, do other thing\n");
        }
        else
        {
            perror("waitpid");
            break;
        }
    }
	return 0;
}

进程程序替换

替换原理

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id并未改变。

当我们要进行替换时，新程序的数据和代码会将原来物理内存中的数据段和代码段进行替换。其实程序替换工作本质就是加载！！！

替换函数

其实有六种以exec开头的函数,统称exec函数：

#include <unistd.h>`
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ...,char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);

int execve(const char *path, char *const argv[], char *const envp[]);

这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。
如果调用出错则返回-1
所以exec函数只有出错的返回值而没有成功的返回值。

这些函数原型看起来很容易混,但只要掌握了规律就很好记。

l(list) : 表示参数采用列表
v(vector) : 参数用数组
p(path) : 有p自动搜索环境变量PATH
e(env) : 表示自己维护环境变量

我们强调一下结尾带e的exec*的函数，其就是表示自己维护环境变量。我们想要子进程全部继承父进程的全部环境变量直接可以。如果单纯再父进程的环境变量中添加一些环境变量可以使用putenv函数。但是我们子进程如果想要自己拥有一个全新的环境变量，我们可以使用exec*函数中后面带e的，他会将父进程继承的环境变量覆盖掉！！！

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

int main()
{
    char *const env[] ={
        (char*)"haha=hehe",
        (char*)"PATH=/",
        NULL
    };
    printf("I am a process, pid: %d\n", getpid());
    //putenv("MYVAL=bbbbbbbbbbbbbbbbbbbbbbbbbbbb");
    pid_t id = fork();
    if(id == 0)
    {
        //extern char**environ;
        sleep(1);
        //execle("./mytest", "mytest", NULL, environ); // 我们传递环境变量表了吗？？no. 子进程默认就拿到了.他是怎么做到的？
        execle("./mytest", "mytest", NULL, env); // 我们传递环境变量表了吗？？no. 子进程默认就拿到了.他是怎么做到的？
        //execl("/usr/bin/python3", "python3", "test.py", NULL);
        //execl("/usr/bin/bash", "bash", "test.sh", NULL);
        //execl("./mytest", "mytest", NULL); // 我们传递环境变量表了吗？？no. 子进程默认就拿到了.他是怎么做到的？
        //char *const argv[] = {
        //    (char*)"ls",
        //    (char*)"-a",
        //    (char*)"-l"
        //};
        //sleep(3);
        //printf("exec begin...\n");
        //execvp("ls", argv);
        //execv("/usr/bin/ls", argv);
        //execl("/usr/bin/ls", "ls", "-a", "-l", NULL); //NULL 不是 "NULL"
        //execlp("ls", "ls", "-a", "-l", NULL); //NULL 不是 "NULL"
        //execl("/usr/bin/top", "/usr/bin/top", NULL); //NULL 不是 "NULL"
        printf("exec end ...\n");
        exit(1);
    }

    pid_t rid = waitpid(id, NULL, 0);
    if(rid > 0)
    {
        printf("wait success\n");
    }
    
    exit(1);
}

exec调用举例如下:

#include <unistd.h>
int main()
{
char *const argv[] = {"ps", "-ef", NULL};
char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
execl("/bin/ps", "ps", "-ef", NULL);
// 带p的，可以使用环境变量PATH，无需写全路径
execlp("ps", "ps", "-ef", NULL);
// 带e的，需要自己组装环境变量
execle("ps", "ps", "-ef", NULL, envp);
execv("/bin/ps", argv);
// 带p的，可以使用环境变量PATH，无需写全路径
execvp("ps", argv);
// 带e的，需要自己组装环境变量
execve("/bin/ps", argv, envp);
exit(0);
}

事实上,只有execve是真正的系统调用,其它五个函数最终都调用 execve,所以execve在man手册第2节,其它函数在man手册第3节。这些函数之间的关系如下图所示。

总结：

细节1：程序替换一旦成功，exec*后续代码不再执行，因为被替换掉了。

细节2：exec*只有失败有返回值，没有成功返回值。

细节3：替换完成，不再创建新的程序。

细节4：创建一个进程先创建PCB、地址空间、页表，再将程序加载到内存中。

这些函数功能上没有任何区别，区别就在于传递的参数不同！

以上就是全部内容，感谢大家观看！！！

W…Y

关注

14
点赞
踩
26

收藏

觉得还不错? 一键收藏
打赏
0
评论
【Linux进程篇】Linux中的等待机制与替换策略

进程等待和进程替换是操作系统中管理进程的两个关键概念。进程等待是当一个进程需要等待某个资源或事件时，它将暂停执行，直到条件满足。这有助于避免资源冲突和死锁，同时允许系统更高效地处理任务。进程替换则是在系统资源受限时，将某些进程从内存中移除，以便为其他更重要或更紧急的进程腾出空间。这种策略有助于优化系统性能，确保关键任务的顺利执行。通过合理设计进程管理策略，可以提高系统的稳定性和响应性。本文将深入探讨进程等待和进程替换的工作原理，包括它们的实现机制、调度算法以及在不同操作系统中的应用。
复制链接

扫一扫