Linux进程控制

酒竹.

已于 2024-04-01 20:17:26 修改

阅读量1.4k

点赞数 36

分类专栏： linux 文章标签： linux 算法运维

于 2024-04-01 17:38:37 首次发布

本文链接：https://blog.csdn.net/weixin_60358305/article/details/137151892

版权

linux 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1.地址空间

1. 程序地址空间

这是我们之前学习的时候见过的空间分布图。事实上这个空间分布图只是虚拟地址的分布，并非实际的物理地址，我们上代码看看。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int g_val = 0;
int main()
{
    pid_t id = fork();
    if(id < 0)
    {
        perror("fork");
        return 0;
    }
    else if(id == 0)
    { //child
        printf("child[%d]: %d : %p\n", getpid(), g_val, &g_val);
    }
    else
    { //parent
        printf("parent[%d]: %d : %p\n", getpid(), g_val, &g_val);
    }
    sleep(1);
    return 0;
}

我们发现，他们的地址和变量值都是一样的。这很好解释，子进程本就相当于父进程的备份，继承父进程的财富，此时父子进程都未对数据进程修改，因此不会发生写时拷贝。

那么我们让子进程发生写时拷贝再来看看。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int g_val = 0;
int main()
{
    pid_t id = fork();
    if(id < 0)
    {
        perror("fork");
        return 0;
    }
    else if(id == 0)
    { 
        //child,子进程肯定先跑完，也就是子进程先修改，完成之后，父进程再读取
        g_val=100;
        printf("child[%d]: %d : %p\n", getpid(), g_val, &g_val);
    }
    else
    {     
        //parent
        sleep(3);
        printf("parent[%d]: %d : %p\n", getpid(), g_val, &g_val);
    }
    sleep(1);
    return 0;
}

这时候我们发现，父子进程的数据不同，也就是发生了写时拷贝，但他们的地址怎么还是一样的。

还是很简单，因为这里的地址并非实际的物理地址，而是虚拟地址。物理地址由OS统一管理，我们平时写代码看到的地址都是虚拟地址。OS负责将虚拟地址转化为物理地址。

2. 进程地址空间

事实上，应该称呼地址空间为进程地址空间。别忘了，一个程序可能会有多个进程，每一个进程都有自己独立的地址空间。

我们看图：

很清晰明了，父子进程有各自的pcb。pcb内含有虚拟地址与物理地址的映射表，当不做数据修改时，虚拟地址指向同一块物理地址；但当某一进程对数据做修改时，OS会在物理地址层发生写时拷贝，但虚拟地址仍是不变的。

3. Linux2.6内核进程调度队列

上图是Linux2.6内核中进程队列的数据结构，之间关系也已经给大家画出来，方便大家理解

一个cpu拥有一个runqueue。

活动队列

时间片还没有结束的所有进程都按照优先级放在该队列
nr_active: 总共有多少个运行状态的进程
queue[140]: 一个元素就是一个进程队列，相同优先级的进程按照FIFO规则进行排队调度,所以，数组下标就是优先级！
从该结构中，选择一个最合适的进程，过程是怎么样的呢？
1. 从0下表开始遍历queue[140]
2. 找到第一个非空队列，该队列必定为优先级最高的队列
3. 拿到选中队列的第一个进程，开始运行，调度完成！
4. 遍历queue[140]时间复杂度是常数！但还是太低效了！
bitmap[5]:一共140个优先级，一共140个进程队列，为了提高查找非空队列的效率，就可以用5*32个比特位表示队列是否为空，这样，便可以大大提高查找效率！

过期队列

过期队列和活动队列结构一模一样
过期队列上放置的进程，都是时间片耗尽的进程
当活动队列上的进程都被处理完毕之后，对过期队列的进程进行时间片重新计算

active指针和expired指针

active指针永远指向活动队列
expired指针永远指向过期队列
可是活动队列上的进程会越来越少，过期队列上的进程会越来越多，因为进程时间片到期时一直都存在的。
没关系，在合适的时候，只要能够交换active指针和expired指针的内容，就相当于有具有了一批新的活动进程！

总结

在系统当中查找一个最合适调度的进程的时间复杂度是一个常数，不随着进程增多而导致时间成本增加，我们称之为进程调度O(1)算法！

2. 进程

2.1 进程的创建

看到这里有没有想到我们之前用到的fork？没错，进程的创建就是要依赖于fork的执行。

2.1.1 fork()函数

在Linux中，fork()函数是一个非常重要的函数，它能够从已有进程中创建一个新的进程。这个新创建的进程就被称为他的子进程，而他就是新建进程的父进程。

我们来看看他的创建过程，这段代码我们之前也用过。

int main()
{
    printf("process is running,pid(): %d,ppid: %d\n",getpid(),getppid());
    pid_t id=fork();//fork创建子进程，子进程fork返回0，父进程返回pid
    sleep(2);
    int num=100;
    if(id==0)
    {
        //子进程
        //int cnt=10;
        while(1)
        {
            num=999;
            printf("child running! id: %d, pid(): %d, ppid(): %d, num: %d\n",id, getpid(),getppid(),num);
            sleep(1);
        }
    }

    else
    {
        while(1)
        {
            sleep(1);
            printf("parent running!id: %d, pid(): %d,ppid(): %d, num: %d\n",id,getpid(),getppid(),num);
        }
    }
    return 0;
}

2.1.2 fork函数的返回值

从上面的实验不难看出，fork()创建子进程后，父子进程会返回不同的数值，因为我们就是依旧返回的值来驱使父子进程做不同的工作。

这里我们可以得出一个结论，fork时，父进程返回的是子进程的pid，子进程返回0，不相信的可以在父进程代码中打印id的值。

fork为什么会返回两个值？

关于fork函数为什么会返回两个值，我们在之前也提过，因为fork函数创建子进程，父子进程会共享后面的代码，而在执行fork函数的return之前，子进程已经创建完毕，因此fork的return语句是父子进程的共享代码，他们都会执行一次。

2.1.3 写时拷贝

写时拷贝我们之前也浅浅提到过，这里再来细说一下。

父子进程虽然都有自己独立的进程空间，但子进程会继承父进程的绝大多数属性，这其中就包括父进程的代码和数据。

我们知道，一个进程的的代码和数据权限分别是只读与可写可读。代码不用多说必然是父子进程共享的，那么数据呢？难道每次创建子进程都拷贝一份新的数据吗？如果我们创建了几千个子进程都不需要对数据进行修改呢？

这里就要让写时拷贝出场了。写时拷贝，顾名思义，只有在需要写的时候才修改。即不需要对数据进行修改时父子进程共享数据，一旦需要修改，物理地址层就会发生写时拷贝，。注意不是虚拟地址，因此我们打印出的父子进程数据的地址是相同的。

下图清晰的展示了写时拷贝的过程。

2.1.4 fork的常规用法

一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。
一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数 <进程替换>

2.1.5 fork调用失败的原因

系统中有太多的进程
实际用户的进程数超过了限制

2.2 进程的终止

2.2.1 进程退出的场景

代码运行完毕，结果正确
代码运行完毕，结果不正确
代码异常终止

2.2.2 进程常见的退出方法

正常终止（可以通过 echo $? 查看进程退出码）：默认退出码为0，代码中可自行修改
1. 从main返回
2. 调用exit
3. _exit
异常退出：
ctrl + c，信号终止

上面提到了进程的退出码，还记得之前我们写main函数最后一句的return 0吗？这里就是设置退出码为0，如果进程执行完毕且结果正确，退出码返回0；如果进程执行完毕但结果产生错误，退出码就会产生别的数据。下图就是部分退出码对应的错误信息。

_exit函数

#include <unistd.h>
void _exit(int status);
参数：status 定义了进程的终止状态，父进程通过wait来获取该值

说明：虽然status是int，但是仅有低8位可以被父进程所用。所以_exit(-1)时，在终端执行$?发现返回值是255。（这句话的含义在后面会解释，_exit的参数与return 类似，进程正常退出就返回该参数值，但在这里，该参数值是一个32位二进制的组成部分）

exit函数

#include <unistd.h>
void exit(int status);

exit最后也会调用_exit, 但在调用_exit之前，还做了其他工作：
1. 执行用户通过 atexit或on_exit定义的清理函数。
2. 关闭所有打开的流，所有的缓存数据均被写入(清空缓存区)
3. 调用_exit

return 退出

return是一种更常见的退出进程方法。执行return n等同于执行exit(n),因为调用main的运行时函数会将main的返回值当做 exit的参数。（值得一提的是，return返回的是函数，只有在main函数中才可以结束进程，但_exit与exit在进程的任何地方都可以终止进程）

2.3 进程的等待

2.3.1 进程等待的必要性

之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。

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

2.3.2 进程等待的方法

wait方法

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);
返回值：
成功返回被等待进程pid，失败返回-1。
参数：
输出型参数，获取子进程退出状态,不关心则可以设置成为NULL

这里的status是一个输出型参数，根据进程退出的状态改变。

waitpid方法

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。

上面代码块中对waitpid函数的参数进行了解释，大家可以自己研读。

关于options可以这么理解，如果传入0则父进程阻塞等待子进程的退出，如果传入WNOHANG则非阻塞式等待。非阻塞式等待即父进程检查有无已经退出的子进程，如果没有，则退出wait，做自己的事，一段时间后再检查。

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

下图为阻塞式等待。

2.4 获取子进程的status

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

这里可以看到，进程的退出信息由二进制的32bit位组成，左边的16个bit位暂未使用，后16个bit位分为最低八位与次低八位。

次低八位存放的是退出码，也即（_exit()或exit()中传入的退出状态值），要获取进程的退出码可执行(status>>8)&0X7F。

最低八位的左侧一位是core dump标志，这一位如果为1，则次低七位的值没有参考价值，表示进程未运行完就被信号杀死。

最低八位的最低七位存放的是进程被信号所杀的信号编号。因此如果要获取退出状态的信号编号，可执行status&0X7F。

以下面这段代码进行实验。

int main()
{
    pid_t id=0;
    id =fork();
    if(id==0)//子进程
    {
        int cnt=10;
        while(cnt--)
        {
            sleep(1);
            printf("子进程正在运行！ 我的pid：%d\n",getpid());
        }
        
        exit(10);//设置子进程正常退出码为10
    }
    else
    {
        int status=0;
        int ret=wait(&status);
        if(ret>0&&(status&0x7F)==0)//子进程已终止，且未被信号干扰
        {
            printf("父进程等待成功！退出码：%d\n",(status>>8)&0xFF);//取退出码

        }
        else if(ret>0)//子进程已终止，但被信号所杀
        {
            printf("进程被信号所杀，信号编号：%d\n",status&0x7F);//取信号编号
        }
    }
    return 0;
}

实验很成功。

//还有进程的阻塞等待与非阻塞等待实验未完成。

2.5 进程的程序替换

2.5.1 程序替换的原理

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

2.5.2 替换函数

共有七种替换函数，但其中六种都是基础用法的变形。

#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[]);

2.5.3 函数解释

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

2.5.4 命名理解

这些函数原型看起来很容易混,但只要掌握了规律就很好记。
l(list) : 表示参数采用列表
v(vector) : 参数用数组
p(path) : 有p自动搜索环境变量PATH（不用传入路径）
e(env) : 表示自己维护环境变量

调用示例：

#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节。

这些函数之间的关系如下图所示。
下图exec函数族一个完整的例子:

2.5.5 应用

下面这段代码实现了创建子进程并将子进程替换为ls -a

int main()
{
    pid_t pid=fork();
    
    if(pid==0)//子进程
    {
        printf("Child process pid:%d\n",getpid());
        execlp("/usr/bin/ls","ls","-a","-l");
        printf("子进程已经替换为ls!\n");
        printf("Already replace! Child process pid:%d\n",getpid());
        exit(10);
    }
    else
    {
        int st=0;
        wait(&st);
        printf("父进程等待子进程成功！子进程退出信息：%d\n",st);
    }
    return 0;
}