Linux 学习之路 -- 进程篇 -- 进程控制

4647的码农历程

已于 2024-04-27 14:29:41 修改

阅读量1.1k

点赞数 24

分类专栏： Linux进程文章标签：学习

于 2024-04-24 21:02:35 首次发布

本文链接：https://blog.csdn.net/2302_79538079/article/details/138134674

版权

Linux进程专栏收录该内容

13 篇文章 0 订阅

订阅专栏

<2>WEXITSTATUS(status)

<5>waitpid的阻塞调用和非阻塞调用

一、进程终止

在我们平常写C/C++代码时，为什么我们要加一个return 0呢？这里可不可以返回其他的数字呢？

不知道大家有没有思考过这些问题，main函数也是函数，在运行之后形成了一个进程。那我们该如何了解进程的运行状况呢？其实就是通过main的返回值来判断程序的运行状况。而main函数的返回值表示进程的退出码，一般我们用0表示进程执行成功，非零表示失败。为什么用非零来表示失败呢？其实在Linux系统中是想用不同的数字表示不同的失败原因。

我们可以用一段代码演示一下

#include<stdio.h>
int main()
{
    printf("hello world\n");
    return 10;
}

运行成功，系统就会打印除hello world，但是父进程要怎么确定这个子进程的运行状态呢？系统中存在一个命令叫 " echo $?" ，bash会保存最近一次进程退出的退出码，如下图所示（下图中最近一次进程退出码变为0，是因为上一次的进程变成了echo $? 这个命令）

当然，退出码并不是给普通用户读的，是给进程读取的，如果我们想要看到进程退出码的错误信息，必需转换成错误描述才可以，这种转换一般有两种方法：1、使用语言和系统自带的犯法，进行转换。2、可以自定义。

<1>使用语言和系统自带的方法，进行转换

系统中存在strerror接口，该接口可以帮助我们进行查看错误码的错误描述。

这里我们打印出一些，供大家参考（直接用for循环即可打印，退出码的范围大概是1 - 133，超过了就变成unkown error，这些在不同的环境下，退出码的大小和个数可能是不同的）；

<2>自定义错误码

我们可以自己写一段代码来描述进程的退出码，如下图

#include<stdio.h>
#include<string.h>
enum{
    success = 0,
    malloc_err,
    open_err,
    close_err
};
void my_strerror(int code)
{
    switch (code)
    {
    case success:
        printf("success\n");
        break;
    case malloc_err:
        printf("malloc fail\n");
        break;
    case open_err:
        printf("open error\n");
        break;
    case close_err:
        printf("close error\n");
        break;
    default:
        printf("unknow\n");
        break;
    }

}
int main()
{
    int code = malloc_err;
    my_strerror(code);
    return code;

}

运行结果

errno：

在进程退出时，有进程退出码，当函数退出时，有函数返回值。而在调用函数里面，我们通常向看到两种结果，一是函数的执行结果，二是函数的执行情况。一般情况下函数的执行结果就代表了函数的执行结果。如果我们函数调用失败，函数会返回特定的值，这个值一般称为错误码，errno函数可以通过错误码来打印出对应信息，本质上这和退出码没什么区别。

<3>小结：

进程的退出情况无非一下三种：

1.进程代码执行完，结果正确；

2.进程代码执行完，结果是不正确的；

3.进程代码没有执行完，进程出异常了；

而进程出现异常，本质就是进程受到了信号，而每个信号都有各自的编号，不同的信号编号代表不同的异常原因。根据上述的三种情况，我们可以使用两个数字来表示进程的具体执行情况(一是信号，二是进程的退出码。如果信号为零，表示进程没有出现异常，如果不为零，表示进程出现了异常情况。如果进程退出码为零表示结果正确，不为零表示结果异常。一般是先看信号，再看退出码，如果信号不为零，根本就得不到退出码)。

信号

<2>两个接口exit / _exit

当然，进程的退出还有exit和_exit接口，准确地来说exit接口是进程退出

只要某个进程调用这个接口，系统就会终止这个进程，status是进程退出时的退出码，_exit接口两个运行结果是一样的，但exit是C语言的库，_exit是系统调用的结果。这两函数的区别是exit 会支持刷新缓冲区，_exit是不支持缓冲区的刷新。缓冲区刷新会让一些信息打印到显示屏上。

int main()
{
    printf("hello world");
    sleep(2);
    exit(0);
}

我们运行这段代码后，一段时间后就会让缓冲区的信息刷新到屏幕上。

而我们把exit改为系统调用接口后，屏幕上就不会出现对应信息，因为缓冲区并没有刷新。

这里显示器上就没有出现对应的信息。exit和_exit的区别就在于此。当然，本质上来说，exit就是_exit的上层封装。用户要终止进程，只能通过系统接口，让操作系统去终止进程，所以最终无论调用哪一个函数，最后调用的时候，都是调_exit接口。为什么还要封装_exit接口呢？很大一个原因就是因为在不同的操作系统下，对应功能的系统调用可能大不相同，编写的代码就只能在特定机器下运行，不具有移植性。所以为了屏蔽这种底层差异，我们就可以通过封装这些系统调用来实现跨平台开发（比如在linux和window操作系统下，要实现进程终止，是由两个完全不同的接口实现的，但是我们平常写代码时只要写exit就可以实现进程终止这个功能，无论是在window还是在linux），这样是我们下载安装包时，经常看到window版，macos版等等。

二、进程等待

<1>简单了解

之前描述过，子进程一旦退出后，父进程不读取子进程数据信息，就会造成僵尸状态（Z）。父进程就需要通过进程等待来接触这个状态。进程等待做的事情其实就是两件，一是父进程通过wait方式回收子进程的资源，二是通过wait方式，获取子进程的退出信息。

首先我们先看一下进程等待相关的系统接口，wait和waitpid。

这里的wstatus都是输出型的参数，我们先设置为NULL。

<2>wait调用

1.wait调用会默认进行阻塞等待，阻塞等待就是子进程不退，父进程也不退，直到子进程死亡，然后才返回。

2.等待任意一个子进程，只要有子进程，都需要等待。

返回值：如果大于零，就是等待子进程的pid，如果小于零，就表示等待失败了。

下面演示一下用wait回收过程

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


int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        int ret = 5;
        while(ret--)
        {
            printf("I am child process, pid:%d, ppid:%d\n",getpid(),getppid());
            sleep(1);
        }
        printf("子进程即将终止\n");
        sleep(1);
        exit(0);//开始变僵尸
    }
    sleep(10);
    pid_t t = wait(NULL);
    if(t > 0)
    {
        printf("pid: %d 回收成功，即将退出\n",t);
        sleep(3);
    }
    return 0;
}

运行结果

我们可以看见，wait确实成功回收了子进程。所以父进程一般先回收完子进程后再退出，所以父进程一般都是最后退出。

<3>waitpid调用

waitpid也具有回收子进程资源的功能，同时该接口还能获取子进程的退出信息。这个函数的返回值含义跟wait并无区别，只是在参数上稍有差异。

三个参数：

pid：pid = - 1，等待任一子进程，与wait等效；wait >0 ，等待其进程ID与pid相等的子进程。

wstatus：表示输出型参数，这里我们获取退出信息时，给定一个int*指针，将退出信息写入指针中

option：0（阻塞）和非阻塞状态，这里我们先设置为0；

下面我们在微调一下上面wait的演示代码，看看waitpid的效果。

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        int ret = 5;
        while(ret--)
        {
            printf("I am child process, pid:%d, ppid:%d\n",getpid(),getppid());
            sleep(1);
        }
        printf("子进程即将终止\n");
        sleep(1);
        exit(1);//开始变僵尸
    }
    sleep(10);
    int status = 0;
    pid_t t = waitpid(id, &status,0);
    if(t > 0)
    {
        printf("pid: %d status: %d  -->回收成功，即将退出\n",t,status);
        sleep(3);
    }
    return 0;
}

运行结果

进程状态其实和wait是一样，在下面的运行结果中，存在一个令人疑惑的点，那就是status的值，明明退出时，给的退出码是“1”，打印出来的却是256。

<4>status

这里特别介绍一下status存储信息的方式，首先根据前面的介绍，进程退出信息包括了进程退出码和退出信号。为了在一个整型变量里面存储这些信号，这里status采取了一种类似于局部性位图的方式存储这两个变量。

下图是status这个变量的32个比特位，其中的一些区域暂不做介绍，只介绍进程退出码和退出时收到信号编号在status里面的存储方式。

所以上文status出现256的原因就好理解了，进程退出码为1，信号编号为0，退出码最低位为32个比特位中的第九位，转换成十进制，也就是256。

如果我们要查看对应的退出码和收到信号，我们可以采用位操作，下面我们微调一下上述代码，将对应的信息打印出来。

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        int ret = 10;
        while(ret--)
        {
            printf("I am child process, pid:%d, ppid:%d\n",getpid(),getppid());
            sleep(1);
        }
        printf("子进程即将终止\n");
        sleep(1);
        exit(1);//开始变僵尸
    }
    sleep(10);
    int status = 0;
    pid_t t = waitpid(id, &status,0);
    if(t > 0)
    {
        printf("pid: %d status: %d 退出码：%d 收到信号：%d-->回收成功，即将退出\n",t,status,status&0x7f,(status>>8)&0xff);
        //0x7f 表示 0000 0000 0000 0000 0000 0000 0111 1111
        //0xff 表示 0000 0000 0000 0000 0000 0000 1111 1111
        sleep(3);
    }
    return 0;
}

通过按位与操作，我们就可以打印对应信息，需要注意的是，我们一般就使用低16位存数据，高十六位字节我们一般看为零，所以对结果不影响。同时进程退出码和收到信号编号中间的一个字节（code dump），我们暂不介绍，这里我们用位多移一位，屏蔽掉这个字节的影响（收到信号的编号占7个字节，为了屏蔽影响，所以这里我们多移了一个字节）

运行结果

正常运行的运行结果

收到信号，进程退出的结果

难道我们每次想要获取进程的运行信息，都要通过位操作进行获取吗？当然不是，系统为我们提供了两个宏，一个叫WIFEXITED(status)，另一个叫WEXITSTATUS(status).

<1>WIFEXITED(status)

该宏就是用来检查进程是否正常退出，其实这个宏本质上来说也是位操作，如果status里面存储的退出码为零，就表示子进程正常终止，表示为真，其余就表示假。

<2>WEXITSTATUS(status)

该宏是用于提取子进程的退出码，在上一个宏为真时，该宏才有调用意义。

这里又引申出一个问题，为什么不用全局变量来存储进程退出码和收到的信号编号，其实这个原因非常简单，就是因为进程的独立性，用户在最开始的时候定义的全局变量属于父进程的数据，如果把子进程的退出信息写入，就会发生写时拷贝，父进程无法看到子进程的退出信息。所以我们必需要调用系统调用来获取子进程的退出信息（该信息在进程的task_struct中，PCB处于内核之中，普通用户无权访问，必需调用系统接口）。

<5>waitpid的阻塞调用和非阻塞调用

前面我们了解过waitpid的参数，其中就包含了一个option参数，这个参数就表示调用的方式，如果是阻塞调用，就为零。如果为非阻塞调用，就可以选择一个宏来表示

这个就表示非阻塞调用。

阻塞调用和非阻塞调用的区别：

我们可以通过日常生活中的例子帮助我们理解这两者之间的区别。

假设张三同学今天想要约李四出门到景点游玩，但是李四因为需要准备随身物品，没那么快下来，所以张三就在李四楼下等李四。等了半天，发现李四还没下来，于是张三就打电话给李四，催李四快点下来，在等待过程中，张三也看了看景点的攻略。但是由于李四比较磨蹭，所以张三只能一直打电话催促，在打了很多次电话后，李四终于下来跟张三去了景点游玩。

在这之后，张三在一个假期中，又向李四发起了组团游玩景点的申请，李四欣然同意。于是在出发当天，张三又跑到李四家楼下等待李四收拾东西。鉴于上一次的经验，张三让李四别挂电话，如果李四收拾好了，直接跟张三说。而张三在此过程中一直等待李四，啥也没干，等到李四收拾完后就再次和李四去景点游玩。

这个张三打电话的过程，就是系统调用，而在第二个例子中的张三打电话，就是阻塞调用。也就是结果不就绪，系统调用就不返回。而在第一个例子中，张三每打一次电话，就是一次系统调用。打了很多次电话，就说明有多次的系统调用（这里的系统调用本质是在检查李四的状态）。这里我们的系统调用不会像第二个例子中的张三打电话那样，没有就绪就一直卡那边动不了，而是直接返回，哪怕李四没有准备好，所以这里的单次系统调用也叫非阻塞调用。而在这里我们不断调用非阻塞系统调用的过程（对应例子中张三一直打电话），就叫作基于轮询(可以看成循环的意思)的非阻塞访问。在这里我们的张三就是父进程，李四就是子进程。

非阻塞调用叫阻塞调用的优点就是非阻塞调用在轮询期间，可以做其他的事情，而阻塞调用只能卡在那里，等待子进程结束。

回到WNOHANG这个参数上来，这个宏就表示非阻塞调用，下面我们用一段代码来看看，这个参数的具体使用。

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        int ret = 5;
        while(ret--)
        {
            printf("I am child process, pid:%d, ppid:%d\n",getpid(),getppid());
            sleep(1);
        }
        printf("子进程即将终止\n");
        exit(1);//开始变僵尸
    }
    //父进程
    while(1)
    {
        int status = 0;
        pid_t t = waitpid(id, &status,WNOHANG);
        if(t > 0)//系统调用成功，并且子进程已经退出
        {
            printf("wait success, pid : %d\n",t);
            break;
        }
        else if(t == 0)//系统调用成功，但子进程没退
        {
            printf("wait success , but child is still running\n");
            //执行其他任务
        }
        else//系统调用失败
        {
            perror("waitpid\n");
            break;
        }
        sleep(1);
    }
    return 0;
}

运行结果

这里我们就可以发现，系统就使用了非阻塞调用的方式，在等待子进程退出过程中，父进程也可以执行一些其他任务，下面用一段示例代码简单演示一下，看看就行，具体任务可自行编写。

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/wait.h>
#define num 6
typedef void(*fun)();

fun task[num];
void printA()
{
    printf("hello! I am task A\n");
}
void printB()
{
    printf("hello! I am task B\n");
}
void printC()
{
    printf("hello! I am task C\n");
}
void printD()
{
    printf("hello! I am task D\n");
}

void Inittask()
{
    task[0] = printA;
    task[1] = printB;
    task[2] = printC;
    task[3] = printD;
    task[4] = NULL;
}
void CarryTask()
{
    for(int i = 0; task[i]; i++)
    {
        task[i]();
    }
}
int main()
{
    Inittask();
    pid_t id = fork();
    if(id == 0)
    {
        int ret = 5;
        while(ret--)
        {
            printf("I am child process, pid:%d, ppid:%d\n",getpid(),getppid());
            sleep(1);
        }
        printf("子进程即将终止\n");
        exit(1);//开始变僵尸
    }
    //父进程
    while(1)
    {
        int status = 0;
        pid_t t = waitpid(id, &status,WNOHANG);
        if(t > 0)//系统调用成功，并且子进程已经退出
        {
            printf("wait success, pid : %d\n",t);
            break;
        }
        else if(t == 0)//系统调用成功，但子进程没退
        {
            printf("wait success , but child is still running\n");
            //可以干别的事情
            printf("**************** task begin ***************\n");
            CarryTask();
            printf("****************  task end  ***************\n");
        }
        else//系统调用失败
        {
            perror("waitpid\n");
            break;
        }
        sleep(1);
    }
    return 0;
}

执行结果