当前位置： 首页 > article >正文

【Linux】进程控制——创建，终止，等待回收

article 2024/11/8 9:46:21

目录

  • 进程创建
    • fork再介绍
    • 写时拷贝
  • 进程终止
    • 退出码
    • 退出方式
  • 进程等待
    • 获取子进程status
    • wait
    • waitpid

在前两篇进程概念中，对进程进行了介绍，进行了初步认识，也认识到了与之相关联的进程地址空间；本文则对进程的生命周期——创建，终止，回收进行介绍，加深对进程的学习。如果对进程相关概念不了解的可以参考——进程概念一，进程概念二

进程创建

进程创建中，fork函数是不可或缺的。

fork再介绍

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

FORK(2)                                                                                                                                         FORK(2)

NAME
       fork - create a child process

SYNOPSIS
       #include <sys/types.h>
       #include <unistd.h>

       pid_t fork(void);
  • fork为系统级调用
  • 类型为pid_t，本质为int
  • 返回值：自进程中返回0，父进程返回子进程id，出错返回-1

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

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

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

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

int main()
{
    printf("before fork pid:%d\n",getpid());
    pid_t pid = fork();
    printf("after fork pid:%d\n",getpid());
}

fork调用
这里看到了三行输出，一行before，两行after。进程35244先打印before消息，然后它又打印after。另一个after
消息有35245打印的。注意到进程35245没有打印before，为什么呢？如下图所示
fork执行流
所以，fork之前父进程独立执行，fork之后，父子两个执行流分别执行。

  • 注意，fork之后，父子进程谁先执行完全由调度器决定。

fork函数返回值

  • 子进程返回0
  • 父进程返回的是子进程的pid

写时拷贝

进程具有独立性，父子进程理论上都具有独立的代码和数据，但是实际中，在不修改数据时，父子进程看到的是同一份代码和数据，只有在子进程修改数据时，才会通过写时拷贝机制，存放这份子进程独有的数据；如下：

int g_val=100;

//进程创建
int main()
{
    
    pid_t pid=fork();
    if(pid>0)//父进程
    {
        int num=4;
        while(num--)
        {
            printf("I am father pid: %d  g_val:%d g_val_addr: %p\n",getpid(),g_val,&g_val);
            sleep(1);
        }

    }
    else if(pid==0)//子进程
    {
        int num=3;
        while (num--)
        {
            printf("I am child ppid: %d  pid:%d  g_val: %d g_val_addr: %p\n",getppid(),getpid(),g_val,&g_val);
            sleep(1);
            if(num==1)
            {
                g_val=200;
                printf("child g_val change to %d\n",g_val);
            }
        }
    }
    else
    {
        perror("fork\n");
    }

    return 0;
}

写时拷贝

可以看到当子进程对g_val进行修改后，父子进程的g_val不再是同一个值，这就是通过写时拷贝实现的。

  • 不解地址为什么还是相同的原因请参考——进程地址空间

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

fork常规用法

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

进程终止

事物有始有终，一个进程既然被创建，那么就会有终止的时候；例如父进程创建子进程去执行相关任务，但是父子进程是独立的，父进程如何知道子进程有没有完成下派的任务呢？这就需要进程退出码了。

退出码

进程退出场景

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

进程退出有以上三种状况；而这三种状况中，前两种的退出码是有意义的，可参考的。代码异常终止一般是收到信号，程序并没有安设想的方式退出，退出码也就没有参考意义了。

正常退出

例如：

int main()
{
    return 99;
}

查看退出码

使用指令echo $?可以查看上一次程序的退出码

查看退出码
可以看到，在运行程序后查看退出码确实是myproc的退出码；但是再次查看时，退出码却是0；这是因为指令本身也是可执行程序，这个退出码0是指令的退出码。

异常终止

异常终止一般是收到了信号，如直接使用kill -9指令直接终止该进程

int main()
{
    while(1)
    {
        printf("pid:%d\n",getpid());
        sleep(1);
    }

    return 99;
}

异常终止
可以看到该退出码并不是我们设想的，所以异常退出的退出码是没有意义的。

而不同的退出码一般会被定义为不同的问题，在C语言中可以使用strerror查看；在C语言中：退出码0代表成功，这也是为什么在main函数中总是return 0的原因，而1到133都对应着不同的问题。

int main()
{
    for(int i=0;i<150;i++)
    {
        printf("%d :%s\n",i,strerror(i));
    }

    return 0;
}

退出码

退出方式

正常终止

  1. 从main返回
  2. 调用exit
  3. _exit

main返回

退出码是给父进程看的，可以判断子进程是否成功运行，在C/C++中。main函数是程序的开始，所以main函数返回会使用return，告诉父进程（OS）子进程的完成情况。

exit返回

NAME
       exit - cause normal process termination

SYNOPSIS
       #include <stdlib.h>

       void exit(int status);

exit为库函数，用于退出当前进程，同时会将退出码设置。如：

int main()
{
    exit(1);
    printf("can u see me?\n");

    return 0;
}

exit
可以看到退出码确实为1，而且并没有执行exit后面的代码，所以exit的作用就是：直接退出当前进程并设置退出码

_exit

NAME
       _exit, _Exit - terminate the calling process

SYNOPSIS
       #include <unistd.h>

       void _exit(int status);

_exit为系统级调用，实际上库函数exit就是对_exit的封装，_exit的用法和exit一致；那有什么区别呢？看下面的例子
_exit
可以看到_exit的代码中，u can see me这句话并没有打印出来。

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

  • _exit 就只是单纯的退出程序
  • 而exit在退出之前还会做一些事，比如冲刷缓冲区，再调用_exit
    _exit对比exit
    所以推荐使用exit

进程等待

为什么要进行进程等待？谁在等待？

首先需要明确：如果父进程不对子进程进行回收，子进程结束后就会变成僵尸进程，有可能导致内存泄漏。
wait

进程等待必要性

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

所以，当子进程创建出来后，父进程需要进行等待，目的是获取进程退出码（次要）和释放子进程的资源（主要），避免僵尸问题。

获取子进程status

系统提供的父进程等待函数有两个wait和waitpid，后者可操作项更多，比较常用；
waitpid
如何获取进程退出码的方式就是通过第二个参数status，所以，在介绍wait waitpid前，先了解父进程是如何获取子进程退出码的。

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

status
只研究低16位比特位：从0号开始到7号为信号部分；8到15才是具体的进程退出码。（位图结构）

退出方式
如何获取退出码呢？虽然status是整型，但使用时却是当作位图来使用的，所以需要进行一些位操作，而系统也已经提供了对应的宏解析status。

WEXITSTATUS(status);//查看进程退出码
WIFEXITED(status);//检测进程是否收到信号退出；若正常退出，则为真，否则为假

WEXITSTATUS就是一个宏：

#define	__WEXITSTATUS(status)	(((status) & 0xff00) >> 8)

注意：WIFEXITED仅用来判断是否收到信号而退出进程，不解析收到几号信号；若收到信号退出则为假，正常退出为真。

WTERMSIG才是用来查看收到几号信号的。

WTERMSIG(status)

宏定义

#define	__WTERMSIG(status)	((status) & 0x7f)

wait

函数原型

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

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

int main()
{
    //WNOHANG;//宏，为1
    pid_t pid=fork();
    if(pid==0)
    {
        // child
        int cnt = 5;
        while (cnt--)
        {
            printf("I am child pid:%d ppid:%d\n", getpid(), getppid());
            sleep(1);
            if (cnt == 0)
            {
                printf("child over\n");
            }
        }
        exit(99);
    }

    pid_t rid=wait(NULL);
    printf("father wait success rid:%d\n",rid);//注意，父子进程本应是各自执行自己的代码的，但是wait会阻塞父进程，直至回收才会执行后面的代码。
    return 0;
}

注意：使用wait回收子进程，父进程会阻塞在wait处，直到回收成功才继续执行后续代码。
wait

waitpid

函数原型

#include<sys/types.h>
#include<sys/wait.h>
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非零，提取子进程退出码。（查看进程的退出码）
WTERMSIG(status)：提取子进程收到的信号。

options:

0：将option设为0，等待方式和wait一样，为阻塞等待。
WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进
程的ID。

  • 这也是另一种等待方式——非阻塞轮询

第三个参数options；提供不同的等待方式；一般为0：阻塞等待；或者WNOHANG：非阻塞轮询——父进程可以执行自己的代码。

阻塞等待
waitpid(pid,&status,0);

int main()
{
    //WNOHANG;//宏，为1
    pid_t pid=fork();
    if(pid==0)
    {
        // child
        int cnt = 3;
        while (cnt--)
        {
            printf("I am child pid:%d ppid:%d\n", getpid(), getppid());
            sleep(1);
            if (cnt == 0)
            {
                printf("child over\n");
            }
        }
        exit(99);
    }
    // father
    int status=0;
    pid_t rid=waitpid(pid,&status,0);
    int cnt = 5;
    while (cnt--)
    {
        printf("I am father pid:%d\n", getpid());
        sleep(1);
    }
    if(rid>0 && WIFEXITED(status))//若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出,不能看出是几号信号）
    {
        printf("wait success:%d exit_code:%d\n",rid,WEXITSTATUS(status));
    }
    else
    {
       printf("kill by sig:%d\n", WTERMSIG(status));//((status) & 0x7f)
    }
    return 0;
}

waitpid

非阻塞轮询
waitpid(pid, &status, WNOHANG)

int main()
{
    pid_t pid = fork();
    if (pid == 0)
    {
        // child
        int cnt = 3;
        while (cnt)
        {
            printf("I am child pid:%d ppid:%d\n", getpid(), getppid());
            sleep(1);
            cnt--;
            if (cnt == 0)
            {
                printf("child over\n");
            }
        }
        exit(1);
    }
    int status=0;
    pid_t rid;
    while(1)
    {
        rid = waitpid(pid, &status, WNOHANG);//非阻塞轮询
        if(rid==0)
        {
            printf("father do other things...\n");
			sleep(1);
        }
        else if (rid > 0)
        {
            if (WIFEXITED(status))
            {
                printf("wait success:%d exit_code:%d\n", rid, WEXITSTATUS(status));
            }
            else
            {
                printf("kill by sig:%d\n", WTERMSIG(status));//((status) & 0x7f)
            }
            break;
        }
        else
        {
            printf("waitpid error...\n");
            break;
        }
    }
    printf("father over\n");
    //sleep(5);

    return 0;
}

waitpid
以非阻塞轮询的方式回收可以看到：父进程每隔一段时间就去查看子进程是否退出，若未退出，则父进程先去忙自己的事情，过一段时间再来查看，直到子进程退出后读取子进程的退出信息。

除了以上正常方式退出，当然也有可能收到信号而退出。如kill -9指令杀掉一个进程。
kill
以上就是进程创建，终止，等待回收的相关问题。


http://www.kler.cn/a/384224.html

相关文章：

  • 17、论文阅读：VMamba：视觉状态空间模型
  • JavaAPI（1）
  • Hive 操作基础（进阶篇✌️）
  • pycharm小游戏贪吃蛇及pygame模块学习（）
  • CIDEr: Consensus-based Image Description Evaluation
  • Ubuntu - 进入紧急模式，无法进入桌面
  • Java多线程详解⑤（全程干货！！！）线程安全问题 || 锁 || synchronized
  • 7-在Ubuntu中使用超级终端Terminator提高工作效率
  • C++入门基础知识141—【关于C++ 拷贝构造函数】
  • Python函数专题：引用传参
  • metrics
  • Java教育技术革新：基于SpringBoot的平台
  • Angular数据绑定详解
  • web——sqliabs靶场——第一关
  • RibbitMQ-安装
  • K8S网络插件故障处理
  • 【STM32】DMA直接存储器读取
  • linux crash使用和环境部署
  • C++从零到满绩——命名空间、输入输出and缺省参数
  • Selenium 高频面试题及答案
  • Java中的远程方法调用——RPC详解
  • solo博客源码使用idea编译运行
  • 信息安全工程师（81）网络安全测评质量管理与标准
  • 关于vue3-router的基础知识点以及注意事项
  • C++ lambda 匿名函数
  • Foundry 单元测试