Linux 系统 - 进程控制

作者：可口也可樂

2022-10-22
湖南
本文字数：8214 字
阅读完需：约 27 分钟

@TOC

零、前言

前篇我们讲解学习了关于进程的概念知识，本章主要讲解关于进程的控制，深入学习进程

一、进程创建

1、fork 函数

概念：

在 linux 中 fork 函数从已存在进程中创建一个新进程（子进程），而原进程为父进程

fork 函数原型：

pid_t fork(void);

复制代码

注意：

使用 fork()函数需要包含头文件<unistd.h>；pid_t 类型需要包含头文件<sys/types.h>
fork 成功后对子进程返回 0，对父进程返回子进程 id，fork 出错返回-1

内核视角看待 fork：

进程调用 fork，内核分配新的内存块和内核数据结构给子进程
将父进程部分数据结构内容拷贝至子进程（例如 PCB 进程控制块，进程地址空间，页表等）
添加子进程到系统进程列表当中，当 fork 返回后开始调度器调度进程

示图：

fork 后执行问题：

当一个进程调用 fork 之后，父子进程共享同一份代码，也就是说整个代码父子进程都可以看到，但是此时父子进程的执行位置都是相同的，也就是说 fork 返回后子进程也是往 fork 之后的代码执行（并非再从头执行）

示例：

#include<stdio.h>#include<unistd.h>#include<sys/types.h>
int main(){    printf("Before fork: pid is %d\n", getpid());    pid_t pid=fork();    if (pid== -1 )//fork错误    {        perror("fork fail");        exit(1);    }    printf("After fork:pid is %d, fork return %d\n", getpid(), pid);    sleep(1);    return 0;}

复制代码

结果：

示图：

2、fork 返回值

返回值：

fork 成功对子进程返回 0，对父进程返回子进程的 pid

写时拷贝

概念：

fork 成功之后父子代码共享，当父子不写入数据时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本

为什么数据要进行写时拷贝:

进程具有独立性，多进程运行，需要独享各种资源，多进程运行期间互不干扰，不能让子进程的修改影响到父进程

为什么不在创建子进程的时候就进行数据的拷贝：

子进程不一定会使用父进程的所有数据，并且在子进程不对数据进行写入的情况下，没有必要对数据进行拷贝，我们应该按需分配，在需要修改数据的时候再分配（延时分配），这样可以高效的使用内存空间，提高 fork 效率，以及 fork 的成功率

代码会不会进行写时拷贝：

90%的情况下是不会的，但这并不代表代码不能进行写时拷贝，例如在进行进程替换的时候，则需要进行代码的写时拷贝

示图：

fork 函数为什么要给子进程返回 0，给父进程返回子进程的 PID：

一个父进程可以创建多个子进程，而一个子进程只能有一个父进程。因此，对于子进程来说，父进程是不需要被标识的；而对于父进程来说，子进程是需要被标识的，因为父进程创建子进程的目的是让其执行任务的，父进程只有知道了子进程的 PID 才能很好的对该子进程进行深入操作

为什么 fork 存在“两个”返回值：

父进程创建子进程时，子进程以父进程为模板构建进程，代码数据父子共享，返回时也是父子进程进行修改数据时，由页表发现该数据是父子进程共享的，所以系统会找到另一个物理空间进行拷贝数据，拷贝数据后再修改数据，达到数据各有一份互不干扰的目的，保证进程的独立性

3、fork 用法

我们创建子进程并不是为了父进程执行一样的代码，而是为了使父子进程同时执行不同的代码段

例如：父进程等待客户端请求，生成子进程来处理请求

用法 1：fork 返回后分流执行不同代码
示例：

#include<stdio.h>#include<unistd.h>#include<stdlib.h>#include<sys/types.h>
int main(){    pid_t id=fork();//创建子进程    if(id==0)    {        //child        int cnt=0;        while(1)        {            printf("I am child: pid:%d ppid:%d\n",getpid(),getppid());            sleep(1);            if(cnt==8)                break;            cnt++;        }           exit(1);//终止进程    }    else if(id>0)    {        //father       int cnt=0;        while(1)        {            printf("I am father: pid:%d ppid:%d\n",getpid(),getppid());            sleep(1);            if(cnt==8)                break;            cnt++;        }       }    return 0;}

复制代码

结果：

用法 2：fork 返回后调用 exec 函数替换进程

注：在下文有着重讲解

4、fork 失败

fork 本质就是向系统要资源，当某个资源不够时则会发生 fork 失败

失败原因：

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

二、进程终止

1、退出码

概念：

其实 main 函数是间接性被操作系统所调用的，当 main 函数调用结束后就应该给操作系统返回相应的退出信息，而这个所谓的退出信息就是以退出码的形式作为 main 函数的返回值返回
我们一般以 0 表示代码成功执行完毕，以非 0 表示代码执行过程中出现错误，一般来说我们写的代码都不太规范，没有根据执行结果返回相应的退出码

注：退出码可以人为定义，也可以使用系统的错误码表

示图：系统错误码表

退出码查看：

使用指令 echo $?

示例：

注：如果 main 没有 return，则 echo $?查看的是最近函数的退出码，一般来说都是 0

2、退出方法

进程退出场景:

代码运行完毕，结果正确，退出码为 0
代码运行完毕，结果不正确，逻辑存在问题，退出码为非 0
代码异常终止，层序崩溃，退出码没有意义

进程常见退出方法：

1) 调用_exit 函数

_exit 函数原型：

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

复制代码

注意：

status 定义了进程的终止状态，父进程通过 wait 来获取该值
虽然 status 是 int，但是仅有低 8 位可以被父进程所用
注：_exit(-1)时，在终端执行 $?发现返回值是 255

示图：

2)调用 exit 函数

exit 函数原型：

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

复制代码

exit 与_exit 的区别：

_exit 仅仅是退出进程
exit 在退出进程前，先执行用户通过 atexit 或 on_exit 定义的清理函数，关闭所有打开的流，所有的缓存数据均写入（刷新缓冲区），最后调用_exit

示图：

示例：

3)main 函数 return

return 是一种更常见的退出进程方法，执行 return n 等同于执行 exit(n)，因为调用 main 的运行时函数会将 main 的返回值当做 exit 的参数

示图：

注意：

只有是在 main 函数的的 return 才算是终止进程，其他函数 return 只是结束函数，因为系统调用的是 main 函数，main 函数返回才是进程的返回
调用 main 函数运行结束后，main 函数的 return 返回值当做 exit 的参数来调用 exit 函数，而使用 exit 函数退出进程前，exit 函数会先执行用户定义的清理函数、冲刷缓冲，关闭流等操作，然后再调用_exit 函数终止进程

4)异常退出

向进程发生信号

如在进程运行过程中向进程发生 kill -9 信号使得进程异常退出，或是使用 Ctrl+C 迫使进程退出

代码运行异常

如代码当中存在野指针问题等 bug 问题使得进程运行时异常退出

3、理解终止

以 OS 角度理解：核心思想-归还资源

释放曾经为管理进程所维护的数据结构资源，并非销毁释放数据结构对象，而是将状态设置为无效并保存起来，下一次需要就直接使用不用申请，相当于建立对应的数据结构“内存池”
释放程序数据和代码占用的空间，并非清空数据和代码，而是将对应内存区域设置为无效，要再次使用时直接覆盖数据和代码就行了
取消曾经该进程在进程队列里的链接关系（避免”野指针“）

三、进程等待

进程等待必要性：

当子进程退出，并不是完全退出，子进程的 PCB 任然存在，父进程如果不等待回收，就可能造成‘僵尸进程’的问题，进而造成内存泄漏
注：进程一旦变成僵尸状态，并不能被父进程给 kill 掉，因为子进程已经死去，只能父进程等待回收
子进程的 PCB 保留着退出前任务执行的信息，而通过回收子进程我们可以知道子进程运行完成，结果对还是不对，或者是否正常退出
注：非必须，依执行的程序和需求而定
尽量使父进程晚于子进程退出，可以规范化进行资源的回收
注：所以一般来说，当我们 fork 之后，就需要父进程等待回收子进程

1、等待方法

wait 方法：

wait 函数原型：

#include<sys/types.h>#include<sys/wait.h>pid_t wait(int*status);

复制代码

注意：

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

waitpid 方法：

waitpid 函数原型：

#include<sys/types.h>#include<sys/wait.h>pid_ t waitpid(pid_t pid, int *status, int options);

复制代码

注意：

返回值：
当正常返回的时候 waitpid 返回收集到的子进程的进程 ID
如果设置了选项 options 为 WNOHANG，而调用中 waitpid 发现没有已退出的子进程可收集,则返回 0；如果调用中出错，则返回-1，这时 errno 会被设置成相应的值以指示错误所在
参数 pid：
Pid=-1，等待任一个子进程，与 wait 等效
Pid>0，等待其进程 ID 与 pid 相等的子进程
参数 status：
参数 status 是一个输出型参数，需要我们传入一个整形变量的地址，以此获取子进程退出的信息
使用对应的宏可以查看我们需要的退出信息：WIFEXITED(status): 若为正常终止子进程返回的状态，则为真（查看进程是否是正常退出）;WEXITSTATUS(status): 若 WIFEXITED 非零，提取子进程退出码（查看进程的退出码）
参数 options：
设置为 0：表示默认的阻塞式等待子进程退出，即子进程没退出就不返回，一直等待到子进程退出回收子进程
设置为 WNOHANG：若 pid 指定的子进程没有结束，则 waitpid()函数返回 0，不予以等待；若正常结束，则返回该子进程的 ID

示例 1：阻塞等待

#include<stdio.h>#include<sys/types.h>#include<sys/wait.h>#include<unistd.h>#include<stdlib.h>int main(){    pid_t id=fork();    if(id==0)    {        printf("I am child process:  pid:%d ppid:%d\n",getpid(),getppid());        sleep(5);       // int* p=12345;       // *p=100;//野指针        exit(123);    }    printf("father wait...\n");    int status=0;    //pid_t ret=wait(&status);//等待特定任意子进程    pid_t ret=waitpid(id,&status,0);//阻塞等待特定子进程    if(ret>0&&WIFEXITED(status))//等待成功并子进程退出正常    {        printf("wait success: wait for id:%d status code:%d\n",ret,WEXITSTATUS(status));    }    else if(ret>0)//等待成功但是子进程退出异常    {        printf("exit error! status codedump:%d sign:%d\n",(status>>7)&1,status&0x7F);    }    return 0;}

复制代码

结果：

示例 2：非阻塞等待

#include <stdio.h>#include <unistd.h>#include <stdlib.h>#include <sys/wait.h>int main(){    pid_t pid;    pid = fork();    if(pid < 0){//fork失败        printf("%s fork error\n",__FUNCTION__);        return 1;    }else if( pid == 0 ){         //child执行        printf("child is run, pid is : %d\n",getpid());        sleep(5);        exit(1);    } else{        //father执行        int status = 0;        pid_t ret = 0;        do{            ret = waitpid(-1, &status, WNOHANG);//非阻塞式等待            if( ret == 0 ){//等待失败则继续等待                printf("child is running\n");                //TODO...等待执行其他任务,待会再等待            }            sleep(1);        }while(ret == 0);        //等待成功打印对应信息        if( WIFEXITED(status) && ret == pid ){            //退出正常输出退出码            printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));        }else{            //退出异常            printf("wait child failed, return.\n");            return 1;        }    }    return 0;}

复制代码

结果：

总结：

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

示图：

2、获取 status

概念：

wait 和 waitpid，都有一个 status 参数，该参数是一个输出型参数，由操作系统进行将退出信息填充
如果传递 NULL，表示不关心子进程的退出状态信息；如果传递变量地址，操作系统会根据该参数将子进程的退出信息反馈给父进程
使用对应的宏可以方便查看我们需要的退出信息：WIFEXITED(status): 若为正常终止子进程返回的状态，则为真（查看进程是否是正常退出）;WEXITSTATUS(status): 若 WIFEXITED 非零，提取子进程退出码（查看进程的退出码）

注：status 不能简单的当作整形来看待，可以当作位图来看待（只有 status 的低 16 比特位有有效信息）

示图：

注意：

如果是正常退出，我们可以进一步获取子进程退出的退出码（退出状态），通过退出码判断进程执行的结果如何，是对还是错
如果是异常退出，那么退出码变没有意义（执行任务已经失败），只需要考虑低 7 位的信息查看是怎样的异常

示例：

#include <sys/wait.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#include <errno.h>int main(){    pid_t pid;    if ( (pid=fork()) == -1 )        perror("fork"),exit(1);    if ( pid == 0 ){        sleep(20);        exit(10);    } else {        int st;        int ret = wait(&st);        if ( ret > 0 && ( st & 0X7F ) == 0 ){ // 正常退出               printf("child exit code:%d\n", (st>>8)&0XFF);        } else if( ret > 0 ) { // 异常退出            printf("sig code : %d\n", st&0X7F );        }    }}

复制代码

结果：

3、理解等待

以 OS 的视角理解：

父进程创建子进程，并调用系统接口 wait/waitpid 进行等待
系统会将当前进程放进等待队列，并将进程的状态设置为非 R
当到一定程度时，系统会唤醒进程，进程由等待队列转为运行队列，同时状态变为 R

四、进程替换

1、替换原理

用 fork 创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支)
如果想执行不同程序，子进程可以调用一种 exec 函数以执行另一个程序
当进程调用一种 exec 函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行

注：调用 exec 并不创建新进程，只是将进程的代码和数据写时拷贝成新程序的代码和数据（达到替换的效果），所以调用 exec 前后该进程的 id 并未改变

示图：

2、替换方法

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自动搜索环境变量PATHe(env) : 表示自己维护环境变量

复制代码

示图：

具体使用介绍：

//子进程替换程序为ls命令execl("/user/bin/ls","ls","-i","-a","-l",NULL);   //注：l表示列表形式，即以可变参数的形式使用程序，最后一个参数需要传入NULL，表示参数传入结束execlp("ls","ls","-i","-a","-l",NULL); //注：对于ls这样的系统命令，其路径被储存在PATH环境变量里，execlp函数会自动到PATH里通过各路径去寻找ls命令；如果系统程序指令，则要么拷贝程序到PATH里的某个路径下，或者添加程序路径到PATH变量里//注：对于这里两个ls其实并不冲突，第一个表示程序的名称，第二个表示如何通过参数列表使用程序（使用时需要带上名称）char* const MY_Env[]={    "MYENV=hello linux",NULL}execle("./mycmd","mycmd",NULL,MY_Env); //注：对于不是当前环境变量，需要自己组装，或者将添加到当前环境变量里char* const MY_acgv[]={    "ls",    ,"-l"    ,"-a"    ,"-i"    ,NULL}execv("/user/bin/ls",MY_acgv); //注：v表示数组的形式传入参数列表execvp("ls",MY_acgv); execve("/user/bin/ls",MY_acgv,env);

复制代码

示例：替换程序为 mycmd

test_exec.c:#include<stdio.h>#include<unistd.h>#include<sys/types.h>#include<wait.h>#include<stdlib.h>int main(){    pid_t id=fork();    if(id==0)    {        //child        printf("I am child :pid:%d ppid:%d\n",getpid(),getppid());        execl("./mycmd","mycmd",NULL);           exit(1);    }    printf("I am father:pid:%d ppid:%d\n",getpid(),getppid());    int status=0;    pid_t ret=waitpid(id,&status,0);    if(ret>0&&WIFEXITED(status))    {        printf("wait for id:%d eixt code:%d\n",id,WEXITSTATUS(status));    }    else if(ret>0)    {        printf("eixt error sign:%d codedump:%d\n",status&0x7F,(status>>7)&1);    }    return 0;}mycmd.c:#include <stdio.h>#include <stdlib.h>
int main(){    for(int i =0; i < 10; i ++)        printf("cmd: %d\n", i);        printf("MYENV: %s", getenv("MYENV"));    return 0;}Makefile:.PHONY:allall: exec_cmd  mycmd    exec_cmd:exec_cmd.c    gcc -o $@ $^mycmd:mycmd.c    gcc -o $@ $^ -std=c99
.PHONY:cleanclean:    rm -f exec_cmd mycmd

复制代码

结果：

注：本质上只有 execve 是真正的系统调用，其它五个函数最终都调用 execve（在系统调用上的一个封装），所以 execve 在 man 手册第 2 节，其它函数在 man 手册第 3 节

示图：

注：对于软件或者程序执行，要预先将存在磁盘里的软件或者程序加载到 CPU 上，而我们也可以将 exec 系列函数看作是一种特殊的加载器

五、实现简易 shell

shell 视角执行：

shell 读取新的一行输入，建立一个新的进程，在这个进程中运行程序并等待这个进程结束，再进行新的输入读取

注意：

对于 shell 来说作为命令行解释器，执行命令需要将执行结果给用户看到，这时候就需要子进程执行，让子进程的结果返回，即父进程等待回收子进程
但是对于一些内建命令则需要 shell 自己执行，例如执行 cd ..返回上层目录，我们希望的并不是子进程返回上层目录，所以需要 shell 自己执行

具体流程:

获取命令行
解析命令行
建立一个子进程（fork）
替换子进程（execvp）
父进程等待子进程退出（wait）

示图：

注：根据这些思路，和我们前面的学的技术，就可以自己来实现一个 shell 了

实现代码：

#include <stdio.h>#include <sys/types.h>#include <unistd.h>#include <wait.h>#include <string.h>#include <stdlib.h>#define MAX 128#define SIZE 32
char cmd_line[MAX];//保存获取输入char* cmd_parse[SIZE];//命令选项
int main(){    //不断执行    while(1)    {        memset(cmd_line,0,sizeof(cmd_line));//清空数据        printf("[zgj@myhost my_mini_shell]$ ");//显示词条        fflush(stdout);//强制刷新
        if(fgets(cmd_line,sizeof(cmd_line)-1,stdin))//获取数据        {            //获取成功，设置结束符            cmd_line[strlen(cmd_line)-1]='\0';//注意这里的下标需要减一，因为最后一个接收到的是回车符\n            //切分命令选项            int index=0;            cmd_parse[index]=strtok(cmd_line," ");            while(cmd_parse[index]!=NULL)            {                index++;                cmd_parse[index]=strtok(NULL," ");            }            //分析指令            if(strcmp(cmd_parse[0],"cd")==0)            {                if(chdir(cmd_parse[1])==0)                    continue;            }            else//非内置命令，子进程执行            {                pid_t id=fork();                if(id==0)                {                    //child                    execvp(cmd_parse[0],cmd_parse);                    exit(1);                }                //father                int status=0;                pid_t ret=waitpid(-1,&status,0);                if(ret>0&&WIFEXITED(status))                {                    printf("exit code:%d\n",WEXITSTATUS(status));                }            }        }    }    return 0;}

复制代码

效果：

发布于: 刚刚阅读数: 6

原文链接:【http://xie.infoq.cn/article/01b1329757a872be6d8bea585】。文章转载请联系作者。

可口也可樂

关注

还未添加个人签名 2022-04-28 加入

还未添加个人简介

发布

暂无评论

创作场景

Linux 系统 - 进程控制

零、前言

一、进程创建

1、fork 函数

2、fork 返回值

写时拷贝

3、fork 用法

4、fork 失败

二、进程终止

1、退出码

2、退出方法

1) 调用_exit 函数

2)调用 exit 函数

3)main 函数 return

4)异常退出

3、理解终止

三、进程等待

1、等待方法

2、获取 status

3、理解等待

四、进程替换

1、替换原理

2、替换方法

五、实现简易 shell

可口也可樂

评论