【Linux】进程控制

二木同学

于 2023-02-25 19:15:30 发布

阅读量5.4k

点赞数 2

分类专栏： Linux 文章标签： linux

本文链接：https://blog.csdn.net/m0_68609336/article/details/128728998

版权

Linux 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

一、进程创建

1. 认识fork

在 Linux 中 fork 函数是非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

#include <unistd.h> 
pid_t fork(void);
//返回值：子进程中返回0，父进程返回子进程id，出错返回-1

进程调用 fork，当控制转移到内核中的 fork 代码后，内核做以下工作：

分配新的内存块和内核数据结构给子进程
将父进程部分数据结构内容拷贝至子进程
添加子进程到系统进程列表当中
fork返回，开始调度器调度

在这里插入图片描述

当一个进程调用 fork 之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但每个进程都将可以开始它们自己的旅程，如：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    pid_t pid;
    printf("Before: pid = %d\n", getpid());

    if ((pid = fork()) == -1) {
      perror("fork error");
      exit(1);
    }
    printf("After: pid = %d, fork return = %d\n", getpid(), pid);
    sleep(1);
    return 0;
}

在这里插入图片描述

这里看到了三行输出，一行 Before，两行 After。进程2423先打印 Before消息，然后它有打印 After。另一个After 消息是2424打印的。注意到进程2424没有打印Before，为什么呢？如下图所示：

在这里插入图片描述

fork之前父进程独立执行，fork之后，父子两个执行流分别执行。注意，fork之后，谁先执行完全由调度器决定

2. fork函数返回值

子进程返回0，
父进程返回的是子进程的pid。

3. 写时拷贝

通常，父子代码共享，父子在不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。具体见下图：

在这里插入图片描述

4. fork一般用法

一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。

一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。

5. fork调用失败的原因

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

二、进程终止

1. 进程退出场景

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

2. 进程常见退出方法

正常终止（可以通过 echo $? 查看进程退出码）：

从main返回
调用exit（库函数）
_exit （系统调用）

异常退出：

ctrl + c，信号终止

3. _exit

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

说明：虽然 status 是 int，但是仅有低8位可以被父进程所用。所以_exit(-1)时，在终端执行$?发现返回值是255

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
  _exit(-1);
}

在这里插入图片描述

4. exit

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

exit 最后也会调用 _exit，但在调用 exit 之前，还做了其他工作：

执行用户通过 atexit或on_exit定义的清理函数。
关闭所有打开的流，所有的缓存数据均被写入
调用_exit

在这里插入图片描述

例：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
  printf("Hello");
  _exit(0);
}

在这里插入图片描述

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
  printf("Hello");
  exit(0);
}

在这里插入图片描述

5. return退出

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

三、进程等待

1. 进程等待的必要性

子进程退出，如果父进程不管不顾，就可能造成“僵尸进程”的问题，进而造成内存泄漏。

另外，进程一旦变成僵尸状态，那就刀枪不入， “杀人不眨眼”的 kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。

最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。

父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

2. 进程等待的方法

Ⅰ. wait方法

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

Ⅱ. 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非零，提取子进程退出码。（查看进程的退出码）
  WIFEXITED(status) 和 WEXITSTATUS(status)是两个宏，除两者外还有其他宏。
- options:
  WNOHANG（非阻塞模式）: 若pid指定的子进程没有结束，则 waitpid() 函数返回0，不予以等待。若正常结束，则返回该子进程的ID。

如果子进程已经退出，调用 wait/waitpid 时，wait/waitpid 会立即返回，并且释放资源，获得子进程退出信息。

如果在任意时刻调用 wait/waitpid，子进程存在且正常运行，则进程可能阻塞。如果不存在该子进程，则立即出错返回。

在这里插入图片描述

3. 获取子进程status

wait 和 waitpid，都有一个 status 参数，该参数是一个输出型参数，由操作系统填充。

如果传递 NULL，表示不关心子进程的退出状态信息。否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。

status不能简单的当作整形来看待，应当作位图来看待，具体细节如下图（只研究status低16比特位）

在这里插入图片描述

当程序运行的过程中异常终止或崩溃，操作系统会将程序当时的内存状态记录下来，保存在一个文件：coredump文件中，这种行为就叫做Core Dump

coredump标志位:

为0表示该进程在退出时没有内存镜像文件的产生（也就是说没有coredump文件产生）
为1则有镜像文件产生，当前程序退出异常

代码示例：

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
int main()
{
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(1);
    }
    else if (pid == 0) {
        //child
        sleep(10);
        exit(10);
    }
    else {
        //parent
        int status;
        int ret = wait(&status);
        if (ret > 0 && (status & 0x7f) == 0) { //正常退出
            printf("child eixt code: %d\n", (status >> 8) & 0xff);//输出退出码
        }
        else if (ret > 0) { //异常退出
            printf("sign code: %d\n", status & 0x7f);//输出退出信号
        }
    }
    return 0;
}

在这里插入图片描述

4. 进程的等待方式：阻塞与非阻塞

进程的阻塞等待方式：

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <stdlib.h>
int main()
{
    pid_t pid = fork();
    if (pid == -1) {
        //__FUNCTION__: C语言定义的宏，程序预编译时预编译器将用所在的函数名，返回值是字符串
        printf("%s fork error\n", __FUNCTION__); // main fork error
        return 1;
    }
    else if (pid == 0) {
        //child
        sleep(5);
        exit(5);
    }
    else {
        int status = 0;
        pid_t ret = waitpid(-1, &status, 0);//阻塞式等待，子进程5s后退出
        printf("This is test for wait\n");
        if (WIFEXITED(status) && ret == pid) { //等待成功
            printf("wait child 5s success, child return code: %d\n", WEXITSTATUS(status));
        }
        else { //等待失败
            printf("wait child failed, return.\n");
            return 1;
        }
    }

    return 0;
}

在这里插入图片描述

进程的非阻塞等待方式：

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <stdlib.h>
int main()
{
    pid_t pid = fork();
    if (pid == -1) {
        //__FUNCTION__: C语言定义的宏，程序预编译时预编译器将用所在的函数名，返回值是字符串
        printf("%s fork error\n", __FUNCTION__); // main fork error
        return 1;
    }
    else if (pid == 0) {
        //child
        printf("child is running, pid: %d\n", getpid());
        sleep(5);
        exit(5);
    }
    else {
        int status = 0;
        pid_t ret = 0;
        do {
            ret = waitpid(-1, &status, WNOHANG); // 非阻塞式等待，非阻塞模式下需要搭配循环，否则会造成孤儿进程
            if (ret == 0) { // 子进程还没有结束
                printf("child is running\n");
            }
            sleep(1);            
        }while (ret == 0);

        if (WIFEXITED(status) && ret == pid) { //等待成功
            printf("wait child 5s success, child return code: %d\n", WEXITSTATUS(status));
        }
        else { //等待失败
            printf("wait child failed, return.\n");
            return 1;
        }
    }

    return 0;
}

在这里插入图片描述

四、进程替换

1. 替换原理

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

在这里插入图片描述

2. 替换函数：exec

有六种以 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[]);

3. 函数解释

这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回。

如果调用出错则返回-1，所以exec函数只有出错的返回值而没有成功的返回值。

4. 命名理解

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

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

函数	参数格式	是否“自带”路径	是否使用当前环境变量
execl	列表	否	是
execlp	列表	是	是
execle	列表	否	否，需自己组装环境变量
execv	数组	否	是
execvp	数组	是	是
execve	数组	否	否，需自己组装环境变量

exec调用举例：

#include <unistd.h>
int main()
{
    execl("/bin/ls", "ls", "-l", NULL);
    return 0;
}

在这里插入图片描述

#include <unistd.h>
#include <stdlib.h>
int main()
{
    char *const argv[] = {"ls", "-l", NULL};
    char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL}; // TERM 环境变量用于终端处理, 在 TERM 设置指定的终端类型
    
    execl("/bin/ls", "ls", "-l", NULL);

    // 带p的，可以使用环境变量PATH，无需写全路径
    execlp("ls", "ls", "-l", NULL);

    // 带e的，需要自己组装环境变量
    execle("ls", "ls", "-l", NULL, envp);

    execv("/bin/ls", argv);

    // 带p的，可以使用环境变量PATH，无需写全路径
    execvp("ls", argv);

    // 带e的，需要自己组装环境变量
    execve("/bin/ls", argv, envp);

    exit(0);
}

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

在这里插入图片描述

五、实现一个简易shell

考虑下面这个与shell典型的互动：

在这里插入图片描述

用下图的时间轴来表示事件的发生次序。其中时间从左向右。shell由标识为sh的方块代表，它随着时间的流逝从左向右移动。shell从用户读入字符串"ls"。shell建立一个新的进程，然后在那个进程中运行ls程序并等待那个进程结束。

在这里插入图片描述

然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序并等待这个进程结束。所以要写一个shell，需要循环以下过程:

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

根据这些思路，和我们前面的学的知识，就可以自己来实现一个shell了。实现代码：

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

#define NUM 1024
#define OPT_NUM 64

char lineCommand[NUM];
char *myargv[OPT_NUM]; // 指针数组
int lastCode = 0;
int lastSig = 0;

int main()
{
    while (1)
    {
        // 输出提示符
        printf("用户名@主机名 当前路径# ");
        fflush(stdout);// 将上面打印的数据刷新出来

        // 获取用户输入, 输入的时候，会输入\n
        // ls -l\n
        char *s = fgets(lineCommand, sizeof(lineCommand) - 1, stdin);
        assert(s != NULL);
        (void)s;// s从未被使用，一些编译器会报警告，这一步是为了不报警告
        // 清除最后一个\n , abcd\n
        lineCommand[strlen(lineCommand) - 1] = 0; // \n --> \0
        // printf("test : %s\n", lineCommand);

        // "ls -a -l -i" -> "ls" "-a" "-l" "-i" -> 1->n
        // 字符串切割
        myargv[0] = strtok(lineCommand, " ");
        int i = 1;
        if (myargv[0] != NULL && strcmp(myargv[0], "ls") == 0)
        {
            myargv[i++] = (char *)"--color=auto";// 设置ls配色方案，不同文件类型颜色不同
        }

        // 如果没有子串了，strtok->NULL, myargv[end] = NULL
        while (myargv[i++] = strtok(NULL, " ")) ;

        // 如果是cd命令，不需要创建子进程,让shell自己执行对应的命令，本质就是执行系统接口
        // 像这种不需要让我们的子进程来执行，而是让shell自己执行的命令 --- 内建/内置命令
        if (myargv[0] != NULL && strcmp(myargv[0], "cd") == 0)
        {
            if (myargv[1] != NULL)
                chdir(myargv[1]);// 系统调用，改变当前工作路径
            continue;
        }
        // 内建命令 --> echo
        if (myargv[0] != NULL && myargv[1] != NULL && strcmp(myargv[0], "echo") == 0)
        {
            if (strcmp(myargv[1], "$?") == 0)
            {
                printf("%d, %d\n", lastCode, lastSig);
            }
            else
            {
                printf("%s\n", myargv[1]);
            }
            continue;
        }
        // 测试字符串切割是否成功, 条件编译
#ifdef DEBUG
        for (int i = 0; myargv[i]; i++)
        {
            printf("myargv[%d]: %s\n", i, myargv[i]);
        }
#endif
        // 执行命令
        pid_t id = fork();
        assert(id != -1);

        if (id == 0)
        {
            execvp(myargv[0], myargv);
            exit(1);
        }
        int status = 0;
        pid_t ret = waitpid(id, &status, 0);
        assert(ret > 0);
        (void)ret;
        lastCode = ((status >> 8) & 0xFF);// 退出码
        lastSig = (status & 0x7F); // 退出信号
    }
}