【Linux 进程控制】—— 进程亦生生不息:起于鸿蒙,守若空谷,归于太虚

0033.Linux 系统调用 权限低,不能直接操作硬件、内核资源;拥有最高权限,系统调用就是切换这两种状态的入口。系统调用是用户态进程向内核态请求操作系统服务的,是用户程序和 Linux 内核之间的"门"。 阅读详情
AI摘要

本文围绕Linux进程控制展开,介绍了进程创建中fork函数的使用、返回值及写时拷贝机制;阐述了进程等待的必要性、方法,以及如何获取子进程status;还讲解了进程终止的场景、退出码、错误码,对比了_exit、exit和return三种退出方式,帮助读者深入理解Linux进程控制。

欢迎来到一整颗红豆的博客✨,一个关于探索技术的角落,记录学习的点滴📖,分享实用的技巧🛠️,偶尔还有一些奇思妙想💡
本文由一整颗红豆原创✍️,感谢支持❤️!请尊重原创📩!欢迎评论区留言交流🌟
个人主页 👉 一整颗红豆
本文专栏➡️Linux驾驭之道 掌控操作系统的艺术与哲学

请添加图片描述

进程创建

再识fork函数

之前在 Linux进程状态 这篇文章中,我们已经为大家介绍过Linux系统中一个非常重要的系统调用 — fork,今天我们在来重谈 fork 函数,让大家对这个系统调用有更深刻的理解。

在 Linux中 fork 函数是非常重要的函数,它从已存在进程中创建⼀个新进程。创建出来的新进程叫做子进程,而原进程则称为父进程。

在Linux参考手册中,fork函数的原型如下:(man 2 fork 指令查看)

NAME
       fork - create a child process

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

       pid_t fork(void);

如上不难看出:

  • fork 函数的功能是创建一个子进程
  • 头文件有 <sys/types.h> 和 <unistd.h>
  • 参数为 void ,返回值为 pid_t (实际上是Linux内核中typedef出来的一个类型)

进程调用 fork,当控制转移到内核中的 fork 代码后,内核做如下几件事:

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

在这里插入图片描述

当⼀个进程调用fork之后,就有两个⼆进制代码相同的进程。并且它们都运行到相同的地方。但每个进程都将可以开始属于它们自己的旅程,看如下程序:

int main(void)
{
    pid_t pid;
    printf("Before: pid is %d\n", getpid());
    if ((pid = fork()) == -1)
        perror("fork()"), exit(1);
    printf("After:pid is %d, fork return %d\n", getpid(), pid);
    sleep(1);
    return 0;
}

输出:

Before: pid is 40176
After:pid is 40176, fork return 40177
After:pid is 40177, fork return 0

这里看到了三行输出,⼀行before,两行after。其中 40176就是父进程啦,40177就是子进程。进程40176先打印before消息,然后它有打印after。另⼀个after消息是进程40177打印的。注意到进程40177没有打印before,为什么呢?

如下图所示:

在这里插入图片描述

当父进程执行到fork创建出子进程时,已经执行了上面的before代码,而创建出子进程后,子进程不会去执行父进程已经执行过的代码,而是和父进程一同执行fork之后的代码。这就是为什么子进程没有打印before的原因

所以,fork之前父进程独立执行,fork之后,父子进程两个执行流分别执行之后的代码。值得注意的是,fork之后,谁先执行完全由调度器决定,并没有明确的先后关系!


fork函数返回值

类型定义:fork() 返回 pid_t 类型(通常为 int 通过 typedef 定义),用于表示进程ID(PID)。

fork创建成功:

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

为什么给父进程返回子进程的pid,这个问题我们之前已经讨论过:

一个父进程可以创建一个或者多个子进程,父进程需要通过返回值获得新创建的子进程的唯一标识符(正整数),从而可以管理创建的多个子进程(如发送信号、等待终止等)

为什么子进程返回0

子进程返回0,标识自己为子进程,子进程通过返回值 0 确认自己的身份。子进程无需知晓父进程的PID(实际上可以通过 getppid() 获取)


fork创建失败:

返回 -1并设置错误码:

  • 当系统资源不足(如进程数超限、内存耗尽)时,fork() 失败。

错误码:

  • 需检查 errno 确定具体原因
if (pid == -1) {
    perror("fork failed"); // 输出类似 "fork failed: Resource temporarily unavailable"
}

常见错误码:

  • EAGAIN:进程数超过限制(RLIMIT_NPROC)或内存不足。
  • ENOMEM:内核无法分配必要数据结构所需内存。

写时拷贝 Copy-On-Write

写时拷贝(COW)是 Linux 中 fork() 系统调用的核心优化机制,它使得进程创建变得高效且资源友好,通常,父子代码共享,父子再不写入时,数据也是共享的,当任意一方试图写入,便以写时拷贝的方式各自⼀份副本。

为什么需要写时拷贝?

在传统的进程创建方式中,fork() 会直接复制父进程的所有内存空间给子进程。这种方式存在明显问题:

  • 内存浪费:如果父进程占用 1GB 内存,子进程即使不修改任何数据,也会立即消耗额外 1GB 内存。
  • 性能低下:复制大量内存需要时间,尤其是对大型进程而言,fork() 会显著延迟程序运行。

COW 的解决思路:

  • 推迟实际的内存复制,直到父子进程中某一方尝试修改内存页时,才进行真正的拷贝。在此之前,父子进程共享同一份物理内存。

具体见下图:

在这里插入图片描述

因为有写时拷贝技术的存在,所以父子进程得以彻底分离!完成了进程独立性的技术保证! 写时拷贝,是⼀种延时申请技术,可以提高整机内存的使用率。

写时拷贝的工作流程

1、 fork() 调用时

  • 共享内存页:内核仅为子进程创建虚拟内存结构(页表),但物理内存页仍与父进程共享。
  • 标记为只读:内核将共享的物理内存页标记为只读(即使父进程原本可写)。

2、进程尝试写入内存

  • 触发页错误:当父进程或子进程尝试修改某个共享内存页时,由于页被标记为只读,CPU 会触发页错误(Page Fault)。

内核介入处理:操作系统会由用户态陷入内核态处理异常

  • 分配新的物理内存页,复制原页内容到新页。
  • 修改触发写入的进程的页表,使其指向新页。
  • 将新页标记为可写,恢复进程执行。

3、后续操作

  • 修改后的进程独享新内存页,另一进程仍使用原页。
  • 未修改的内存页继续共享,不做复制,操作系统不做任何无意义的事情。

进程等待

之前我们在讲进程概念的时候讲过,如果父进程创建出子进程后,如果子进程已经退出,父进程却没有对子进程回收,那么就子进程就会变成 “僵尸进程” ,造成内存泄露等问题。

在Linux系统中,进程等待是父进程通过系统调用等待子进程终止并获取其退出状态的过程,主要目的是避免僵尸进程并回收子进程资源。

进程等待的必要性

僵尸进程问题:

  • 子进程终止后,其退出状态会保留在进程表中,直到父进程读取。若父进程未处理,子进程将保持僵尸状态(Zombie),占用系统资源。
  • 状态收集:父进程需知晓子进程的执行结果(成功、错误代码、信号终止等)。
  • 资源回收:内核释放子进程占用的内存、文件描述符等资源。

进程等待的方法

wait

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

具体功能:

  • 阻塞父进程,直到等待到任意一个子进程终止。

参数:

  • status:输出型参数,用来存储子进程退出状态的指针(可为 NULL,表示不关心状态)。

返回值:

  • 成功:返回终止的子进程PID。失败:返回-1(如无子进程)。

waitpid

#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *status, int options);
  • 功能:更灵活的等待方式,可指定子进程或非阻塞等待模式。

参数:

pid:

  • >0:等待指定 PID 的子进程。
  • -1:等待任意子进程(等效于 wait)。
  • 0:等待同一进程组的子进程。

status:同 wait,输出型参数,表明子进程的退出状态。

options: 默认为0,表示阻塞等待

  • WNOHANG:非阻塞模式,无子进程终止时立即返回 0。
  • WUNTRACED:报告已停止的子进程(如被信号暂停)。

返回值:

  • 成功:返回子进程PID。
  • WNOHANG 且无子进程终止:返回0。
  • 失败:返回-1。

做个总结:

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

在这里插入图片描述


获取子进程 status

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

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

status 不能简单的当作整形来看待,可以当作位图来看待,具体细节如下图
(只研究 status 低16比特位):

在这里插入图片描述


如何理解呢?
子进程的退出分为两种情况:

  1. 正常终止

高 8 位(第 8 ~ 15 位):保存子进程的退出状态(退出码)(即 exit(code) 或 return code 中的 code 值)。

第 7 位:通常为 0,表示正常终止。

示例:

若子进程调用 exit(5),表明子进程是正常退出,则 status 的高 8 位为 00000101(即十进制 5)。

  1. 被信号所杀导致终止

低 7 位(第 0 ~ 6 位):保存导致子进程终止的信号编号。

第 7 位:若为 1,表示子进程在终止时生成了 core dump 文件(用于调试)。有关 core dump 文件,后面会讲,大家这里先了解一下即可。

第 8 ~ 15 位:未使用(通常为 0)。

示例:

若子进程因 SIGKILL(信号编号 9)终止,则 status 的低 7 位为 0001001(即十进制 9)。

  • 做个小总结:
低 16 位结构:
| 15 14 13 12 11 10 9 8 | 7 | 6 5 4 3 2 1 0 |
---------------------------------------------
正常终止 → [ 退出状态(高8位) ]  0  [ 未使用 ]
被信号终止 → [   未使用(全0)   ] c  [ 信号编号 ]

如何解析 status?

难道真的需要我们将 status 当作位图,使用位操作来提取子进程的退出信息吗?
这么做对我们程序员来说当然小菜一碟,不过有点多余了,没必要。Linux系统为我们定义了多种宏用来提取 status,方便且专业。

使用宏定义检查 status 的值:

宏功能
WIFEXITED(status)若子进程正常终止(exit 或 return)返回真。
WEXITSTATUS(status)若 WIFEXITED 为真,返回子进程的退出码(exit 的参数或 return 的值)。
WIFSIGNALED(status)若子进程因信号终止返回真。
WTERMSIG(status)若 WIFSIGNALED 为真,返回导致终止的信号编号。
WCOREDUMP(status)若子进程生成了核心转储文件返回真。

常用的两个宏:

  • WIFEXITED(status): 若为正常终止子进程返回的状态,则为真。(查看进程是 否是正常退出)
  • WEXITSTATUS(status): 若WIFEXITED非零,提取子进程退出码。(查看进程的 退出码)

示例一:子进程正常退出

int main()
{
    pid_t pid = fork();
    if (pid == 0)
    { // 子进程
        printf("子进程运行中... PID=%d\n", getpid());
        // 1. 正常退出:调用 exit(42)
        exit(42);
    }
    else
    { // 父进程
        int status;
        waitpid(pid, &status, 0); // 等待子进程结束
        if (WIFEXITED(status))
        { // 正常退出
            printf("子进程正常退出,退出码: %d\n", WEXITSTATUS(status));
        }
        else if (WIFSIGNALED(status))
        { // 被信号终止
            printf("子进程被信号终止,信号编号: %d\n", WTERMSIG(status));
        }
    }
    return 0;
}

输出:

子进程运行中... PID=56153
子进程正常退出,退出码: 42

示例二:子进程被信号终止

int main()
{
    pid_t pid = fork();
    if (pid == 0)
    { // 子进程
        printf("子进程运行中... PID=%d\n", getpid());
        int *p = NULL;
        *p = 100;  // 对空指针解引用,触发 SIGSEGV 被信号终止
    }
    else
    { // 父进程
        int status;
        waitpid(pid, &status, 0); // 等待子进程结束
        if (WIFEXITED(status))
        { // 正常退出
            printf("子进程正常退出,退出码: %d\n", WEXITSTATUS(status));
        }
        else if (WIFSIGNALED(status))
        { // 被信号终止
            printf("子进程被信号终止,信号编号: %d\n", WTERMSIG(status));
        }
    }
    return 0;
}

输出:

子进程运行中... PID=56203
子进程被信号终止,信号编号: 11

阻塞等待与非阻塞等待

在 Unix/Linux 中,父进程通过 wait 或 waitpid 函数等待子进程结束。它们的核心区别在于是否允许父进程在等待子进程时继续执行其他任务。

阻塞等待(Blocking Wait)

父进程调用 waitpid 后,会一直挂起(阻塞),直到目标子进程终止。在阻塞期间,父进程无法执行其他操作,直到子进程退出。

pid_t waitpid(pid_t pid, int *status, 0);  // options 参数为 0

示例:

int main()
{
    int status;
    pid_t child_pid = fork();
    if (child_pid == 0)
    {
        // 子进程执行任务
        exit(10);
    }
    else
    {
        // 父进程阻塞等待子进程结束
        waitpid(child_pid, &status, 0);
        if (WIFEXITED(status))
        {
            printf("子进程退出码: %d\n", WEXITSTATUS(status));
        }
    }
}

非阻塞等待(Non-blocking Wait)

父进程调用 waitpid 时,若子进程未结束,则父进程立即返回,而不是挂起。父进程可以继续执行其他任务,同时定期检查子进程状态。需结合循环实现非阻塞式轮询(polling)。

关键选项:宏 WNOHANG(定义在 <sys/wait.h> 中)。

pid_t waitpid(pid_t pid, int *status, WNOHANG);

示例:非阻塞轮询方式

int main()
{
    int status;
    pid_t child_pid = fork();
    if (child_pid == 0)
    {
        sleep(3); // 子进程休眠 3 秒后退出
        exit(10);
    }
    else
    {
        while (1)
        {
            pid_t ret = waitpid(child_pid, &status, WNOHANG);
            if (ret == -1)
            {
                perror("waitpid");
                break;
            }
            else if (ret == 0)
            {
                printf("子进程未结束,父进程继续工作...\n");
                sleep(1); // 避免频繁轮询消耗 CPU
            }
            else
            {
                if (WIFEXITED(status))
                {
                    printf("子进程退出码: %d\n", WEXITSTATUS(status));
                }
                break;
            }
        }
    }
}

阻塞等待和非阻塞等待的对比:

场景阻塞等待非阻塞等待
父进程任务优先级必须立即处理子进程结果需同时处理其他任务
子进程执行时间较短或确定较长或不确定
资源消耗CPU 空闲,无额外开销需轮询,可能占用更多 CPU
典型应用简单脚本、单任务场景多进程管理、事件驱动程序

进程终止

进程= 内核数据结构 + 进程自己的代码和数据

进程终止是进程生命周期的最后一个阶段,涉及资源释放、状态通知及父进程回收等关键步骤。进程终止的本质是释放系统资源,就是释放进程申请的相关内核数据结构和对应的代码和数据。

进程退出场景

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

如何理解这三种进程退出的场景呢?举个例子

代码运行完毕,结果正确

  • 程序完整执行了所有逻辑,未触发任何错误或异常。
  • 输出结果与预期完全一致,符合功能需求或算法目标。
int sum(int a, int b)
{
    return a + b;
}

int main()
{
    int result = sum(3, 5);
    printf("Result: %d\n", result); // 输出 8,结果正确
    return 0;
}

输出:

Result: 8

代码运行完毕,结果不正确

  • 程序正常结束(无崩溃或异常),但输出结果与预期不符。
  • 通常由逻辑错误、算法错误或数据处理错误导致。

例如:

// 错误实现:本应计算阶乘,但初始值错误
int factorial(int n)
{
    int result = 0; // 错误!应为 result = 1
    for (int i = 1; i <= n; i++)
    {
        result *= i;
    }
    return result;
}

int main()
{
    printf("5! = %d\n", factorial(5)); // 输出 0,结果错误
    return 0;
}

代码未执行完毕,异常终止

  • 程序未执行完毕就中途崩溃或被强制终止。
  • 通常由运行时错误、资源限制或外部信号触发。
  • 比如除零错误,对空指针解引用等异常

例如:

int main()
{
    int *ptr = NULL;
    *ptr = 42;  // 对空指针解引用,触发段错误
    printf("Value: %d\n", *ptr);
    return 0;
}

段错误:

Segmentation fault

再比如:

int main()
{
    int a = 10;
    int b = a / 0; // 程序除零异常
    printf("Value: %d\n", b);
    return 0;
}

浮点数异常:

Floating point exception

进程常见退出方法

正常终止(可以通过 echo $? 查看进程退出码)

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

异常退出:

  1. ctrl + c,信号终止

进程退出码

进程退出码(退出状态)可以告诉我们最后⼀次执行的命令的状态。在命令结束以后,我们可以知道命令是成功完成的还是以错误结束的。通常是你程序中mian函数的返回值,其基本思想是,程序返回退出代码 0 时表示执行成功,没有问题。 0 以外的任何代码都被视为不成功。

退出码是一个 8 位无符号整数(8-bit unsigned integer),因此取值范围为 2^8=256 个值。

Linux Shell 中的常见退出码:

在这里插入图片描述

  • 退出码 0 表示命令执行有误,这是完成命令的理想状态。
  • 退出码 1 我们也可以将其解释为 “不被允许的操作”。例如在没有 sudo 权限的情况下使用 yum;
  • 130 ( SIGINT 或 ^C )和 143 ( SIGTERM )等终止信号是非常典型的,它们属于 128+n 信号,其中 n 代表信号编号。

这里需要补充一点:

进程退出码和错误码是两个完全不同的概念,不要混为一谈!

错误码

在 Linux 系统中,错误码(Error Codes)是操作系统用于标识程序运行中遇到的各类问题的核心机制。这些错误码通过全局变量 errno(定义在 <errno.h> 头文件中)传递,帮助开发者快速定位和调试问题。

要理解错误码,首先要认识全局变量 error

例如:fork函数调用失败后,会立刻返回-1,并设置全局变量 error

在这里插入图片描述

  • 定义:errno 是一个线程安全的整型变量,用于存储最近一次系统调用或库函数调用失败的错误码。

特性:

  • 成功调用不会重置 errno,因此必须在调用后立即检查其值。
  • 每个线程有独立的 errno 副本(多线程安全)。

头文件:

#include <errno.h>

与之对应的是 strerror 函数,该函数可以将对应的错误码转化成字符串描述的错误信息打印出来,方便程序员调试代码。

实际上,我们可以通过 for 循环来打印查看Linux系统下所有的错误码以及其错误信息:

int main()
{
    for (int i = 0; i < 135; ++i)
    {
        printf("%d-> %s\n", i, strerror(i));
    }
    return 0;
}

不难看出,在Linux系统下,一共有 0 ~ 133 总共134个错误码,其中 0 表示 success ,即程序运行成功, 1 ~ 133 则分别对应一个错误信息。

0-> Success
1-> Operation not permitted
2-> No such file or directory
3-> No such process
4-> Interrupted system call
5-> Input/output error
6-> No such device or address
7-> Argument list too long
8-> Exec format error
9-> Bad file descriptor
10-> No child processes
11-> Resource temporarily unavailable
12-> Cannot allocate memory
13-> Permission denied
14-> Bad address
15-> Block device required
16-> Device or resource busy
17-> File exists
18-> Invalid cross-device link
19-> No such device
20-> Not a directory
21-> Is a directory
22-> Invalid argument
23-> Too many open files in system
24-> Too many open files
25-> Inappropriate ioctl for device
26-> Text file busy
27-> File too large
28-> No space left on device
29-> Illegal seek
30-> Read-only file system
31-> Too many links
32-> Broken pipe
33-> Numerical argument out of domain
34-> Numerical result out of range
35-> Resource deadlock avoided
36-> File name too long
37-> No locks available
38-> Function not implemented
39-> Directory not empty
40-> Too many levels of symbolic links
41-> Unknown error 41
42-> No message of desired type
43-> Identifier removed
44-> Channel number out of range
45-> Level 2 not synchronized
46-> Level 3 halted
47-> Level 3 reset
48-> Link number out of range
49-> Protocol driver not attached
50-> No CSI structure available
51-> Level 2 halted
52-> Invalid exchange
53-> Invalid request descriptor
54-> Exchange full
55-> No anode
56-> Invalid request code
57-> Invalid slot
58-> Unknown error 58
59-> Bad font file format
60-> Device not a stream
61-> No data available
62-> Timer expired
63-> Out of streams resources
64-> Machine is not on the network
65-> Package not installed
66-> Object is remote
67-> Link has been severed
68-> Advertise error
69-> Srmount error
70-> Communication error on send
71-> Protocol error
72-> Multihop attempted
73-> RFS specific error
74-> Bad message
75-> Value too large for defined data type
76-> Name not unique on network
77-> File descriptor in bad state
78-> Remote address changed
79-> Can not access a needed shared library
80-> Accessing a corrupted shared library
81-> .lib section in a.out corrupted
82-> Attempting to link in too many shared libraries
83-> Cannot exec a shared library directly
84-> Invalid or incomplete multibyte or wide character
85-> Interrupted system call should be restarted
86-> Streams pipe error
87-> Too many users
88-> Socket operation on non-socket
89-> Destination address required
90-> Message too long
91-> Protocol wrong type for socket
92-> Protocol not available
93-> Protocol not supported
94-> Socket type not supported
95-> Operation not supported
96-> Protocol family not supported
97-> Address family not supported by protocol
98-> Address already in use
99-> Cannot assign requested address
100-> Network is down
101-> Network is unreachable
102-> Network dropped connection on reset
103-> Software caused connection abort
104-> Connection reset by peer
105-> No buffer space available
106-> Transport endpoint is already connected
107-> Transport endpoint is not connected
108-> Cannot send after transport endpoint shutdown
109-> Too many references: cannot splice
110-> Connection timed out
111-> Connection refused
112-> Host is down
113-> No route to host
114-> Operation already in progress
115-> Operation now in progress
116-> Stale file handle
117-> Structure needs cleaning
118-> Not a XENIX named type file
119-> No XENIX semaphores available
120-> Is a named type file
121-> Remote I/O error
122-> Disk quota exceeded
123-> No medium found
124-> Wrong medium type
125-> Operation canceled
126-> Required key not available
127-> Key has expired
128-> Key has been revoked
129-> Key was rejected by service
130-> Owner died
131-> State not recoverable
132-> Operation not possible due to RF-kill
133-> Memory page has hardware error
134-> Unknown error 134

错误码的应用:

int main()
{
    FILE *fp = fopen("invalid.txt", "r");//以只读方式打开不存在的文件会出错
    if (fp == NULL)
    {
        // 使用 strerror 获取错误描述
        printf("%d->%s\n", errno,strerror(errno));            
        return 1; //退出码设为1
    }
    return 0;
}

输出:

2->No such file or directory

使用错误码和对应的错误信息可以帮助程序员快速定位错误模块,调试程序,掌握错误码的使用与调试技巧,是提升 Linux 编程效率和系统可靠性的关键。


_exit函数和exit函数

_exit函数

在 Linux 系统中,_exit() 是一个直接终止进程的系统调用,它会立即终止当前进程,并通知操作系统回收资源,但不执行任何用户空间的清理操作。

#include <unistd.h>
void _exit(int status);
  • 参数 status:进程的退出状态码,范围是 0~255。父进程可以通过 wait() 或 waitpid() 获取该状态码。
  • 返回值:无(进程直接终止,不会返回调用者)。

当前进程调用 _exit() 后,操作系统会立即介入,会从用户态陷入内核态,执行以下操作:

  • 关闭所有文件描述符:内核会关闭进程打开的文件、套接字、管道等资源,但不会刷新标准 I/O 库(如 stdio)的缓冲区。
  • 释放用户空间内存:回收进程的代码段、数据段、堆、栈等内存资源。
  • 发送 SIGCHLD 信号: 通知父进程子进程已终止,并传递退出状态码 status。
  • 终止进程:进程的状态变为 ZOMBIE(僵尸进程),直到父进程通过 wait() 回收其资源。

本质上,_exit() 最终会调用 Linux 内核的 exit_group 系统调用(sys_exit_group),终止整个进程及其所有线程。其内核处理流程如下:

释放进程资源:

  • 关闭所有文件描述符。
  • 释放内存映射(mmap)和虚拟内存区域。
  • 解除信号处理程序绑定。

更新进程状态:

  • 将进程状态设为 TASK_DEAD
  • 向父进程发送 SIGCHLD 信号。

调度器介入:

  • 从运行队列中移除进程。
  • 切换到下一个进程执行。

exit函数

在 C/C++ 语言中,exit 是一个用于正常终止程序执行的标准库函数。它会执行一系列清理操作后终止进程,并将控制权交还给操作系统。

#include <stdlib.h>
void exit(int status);  // C 

#include <cstdlib>
void exit(int status);  // C++ 
  • 参数 status:进程的退出状态码,范围 0~255(0 通常表示成功,非零表示异常)。
  • 返回值:无(进程终止,不会返回调用者)。

进程调用 exit 时,按以下顺序执行操作:

  1. 调用 atexit 注册的函数:按注册的逆序执行所有通过 atexit 或
    at_quick_exit(若使用quick_exit)注册的函数。
  2. 刷新所有标准 I/O 缓冲区:清空 stdout、stderr 等流的缓冲区。 注意: stderr 默认无缓冲,stdout 在交互式设备上是行缓冲。
  3. 关闭所有打开的文件流:调用 fclose 关闭所有通过 fopen 打开的文件。 注意:不会关闭底层文件描述符(需手动 close)。
  4. 删除临时文件:删除由 tmpfile 创建的临时文件。
  5. 终止进程:向操作系统返回状态码 status。父进程可通过 wait 或 waitpid 获取该状态码。

其实本质上,exit 是一个标准库函数,最后也会调用_exit,但是在这之前,exit还做了其他的清理工作:

在这里插入图片描述

我们举个例子,帮大家直观的感受一下这两者的区别:

示例一:使用 exit 函数

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

输出:

[root@localhost linux]# ./a.out
hello[root@localhost linux]#

示例二:使用 _exit 函数

int main()
{
    printf("hello");
    _exit(0);
}

输出:

[root@localhost linux]# ./a.out
[root@localhost linux]#

聪明的同学很快就知道了,我们通过 printf 打印 “hello” 并没有加上换行符,所以“hello”
在缓冲区内没有被立即刷新,所以当我们使用exit终止进程时,exit会帮我们做相应的清理工作,包括刷新I/O缓冲区。而调用_exit时则不会刷新,进程直接退出。

return 退出

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

状态码传递:

main函数中的 return 语句返回一个整数值(通常称为退出状态码),表示程序的执行结果:

  • 0:表示程序成功执行。
  • 非0:表示程序异常终止(具体数值由程序员定义)。

return与exit()的关系

隐式调用exit():

  • 在 main 函数中使用 return 时,C/C++运行时会自动调用 exit() 函数,并将返回值作为参数传递给它。
int main()
{
    return 42;  // 等价于 exit(42);
}

return的执行流程

当在main函数中执行return时,程序会做以下几件事:

  • 返回值传递:将返回值传递给运行时环境。

清理操作:

  • 调用局部对象的析构函数(按照创建顺序的逆序)。
  • 调用全局对象的析构函数(同样逆序)。

调用exit():运行时调用exit(),执行以下操作:

  • 刷新所有I/O缓冲区(如 std::cout)。
  • 关闭通过 fopen 打开的文件流。
  • 执行通过 atexit() 注册的函数。

终止进程:将控制权交还给操作系统。

值得注意的一点是:在非main函数的其他函数中使用 return 仅退出当前函数,返回到调用者,不会终止进程。


_exit、exit 和 return 对比

以下是一个详细的表格供大家理解参考

特性_exit() (系统调用)exit() (标准库函数)return (在 main 中)
所属标准POSIX 系统调用C/C++ 标准库函数C/C++ 语言关键字
头文件<unistd.h><stdlib.h>(C)、<cstdlib>(C++)无(语言内置)
执行流程立即终止进程,不执行任何用户空间清理。1. 调用 atexit 注册的函数
2. 刷新 I/O 缓冲区
3. 关闭文件流
1. 调用 C++ 局部对象析构函数
2. 隐式调用 exit() 完成后续清理
清理操作内核自动回收进程资源(内存、文件描述符),不刷新缓冲区、不调用析构函数清理标准库资源(刷新缓冲区、关闭文件流),但不调用 C++ 局部对象析构函数调用 C++ 局部和全局对象析构函数,并触发 exit() 的清理逻辑
多线程行为立即终止所有线程,可能导致资源泄漏终止整个进程,但可能跳过部分线程资源释放(如线程局部存储)同 exit(),但在 C++ 中会正确析构主线程的局部对象
C++ 析构函数调用❌ 不调用任何对象的析构函数(包括全局对象)❌ 不调用局部对象析构函数
✅ 调用全局对象析构函数(C++)
✅ 调用局部和全局对象析构函数(C++)
缓冲区处理❌ 不刷新 stdio 缓冲区(如 printf 的输出可能丢失)✅ 刷新所有 stdio 缓冲区✅ 通过隐式调用 exit() 刷新缓冲区
适用场景1. 子进程退出(避免重复刷新缓冲区)
2. 需要立即终止进程(绕过清理逻辑)
1. 非 main 函数的程序终止
2. 需要执行注册的清理函数(如日志收尾)
1. 在 main 函数中正常退出
2. 需要确保 C++ 对象析构(RAII 资源管理)
错误处理直接传递状态码给操作系统,无错误反馈机制可通过 atexit 注册错误处理函数,但无法捕获局部对象析构异常可通过 C++ 异常机制处理错误(需在 main 中捕获)
信号安全✅ 可在信号处理函数中安全调用(如 SIGINT)❌ 不可在信号处理函数中调用(可能死锁)❌ 不可在信号处理函数中使用(仅限 main 函数流程)
资源泄漏风险高(临时文件、未释放的手动内存等需内核回收)中(未关闭的文件描述符、手动内存需提前处理)低(依赖 RAII 自动释放资源)
底层实现直接调用内核的 exit_group 系统调用调用 C 标准库的清理逻辑后,最终调用 _exit()编译器生成代码调用析构函数,并跳转到 main 结尾触发 exit()

最后总结下:

  • _exit():最底层的终止方式,适合需要绕过所有用户空间清理的场景(如子进程退出)。
  • exit():平衡安全与效率,适合非 main 函数的程序终止,但需注意 C++ 对象析构问题。
  • return:C++ 中最安全的退出方式,优先在 main 函数中使用,确保资源自动释放。

写在最后

本文到这里就结束了,后面的文章我们会展开讲解有关 Linux操作系统的更多话题,带你从新手小白 成长为一名 Linux 糕手, 感谢您的观看!

如果你觉得这篇文章对你有所帮助,请为我的博客 点赞👍收藏⭐️ 评论💬或 分享🔗 支持一下!你的每一个支持都是我继续创作的动力✨!🙏
如果你有任何问题或想法,也欢迎 留言💬 交流,一起进步📚!❤️ 感谢你的阅读和支持🌟!🎉
祝各位大佬吃得饱🍖,睡得好🛌,日有所得📈,逐梦扬帆⛵!

基于强化学习控制策略的三相逆变器仿真 强化学习控制器的核心在于定义状态空间、动作空间、奖励函数以及选择合适的强化学习算法(例如DQN、DDPG等)。对于三相逆变器,状态可以是输出电压、电流等信息;动作则可能是调制指数的变化量;奖励函数则应鼓励快速准确地跟踪参考信号。定义状态空间和动作空间状态空间可以包括逆变器的输出电压、电流及其变化率等信息。动作空间则是控制器可执行的动作,例如PWM信号的调整幅度。matlab深色版本% 定义状态和动作空间维度numObs = 6;% 假设有六个状态变量(例如三相电压和电流) 阅读详情

相关推荐

是德频谱分析仪相位噪声测量实战指南:从原理到精准操作

本文详细介绍了是德频谱分析仪在相位噪声测量中的实战操作指南,从基础概念到高级技巧全面解析。通过5G基站时钟测量等实际案例,展示如何利用是德N9030B等设备精准测量相位噪声,并分享设备预热、参数设置、环境干扰排除等关键操作要点,帮助工程师提升测量精度和效率。

jenkins8butler的博客 232

彼【Linux 进程控制】—— 进程亦生生不息:起于鸿蒙,守若空谷,归于太虚v

总得来说,此配置文件定义了一个本地代码助手,通过HTTP API连接到一个 Qwen2.5-Coder 模型,支持代码补全、编辑、聊天等功能,并集成了开发环境的多维度上下文(代码、终端、文档等)。apiBase: 模型API的终端地址(http://ip:port/v1),指向一个本地或远程服务。点击右上角绿色的勾,就能将代码写入文件,如果代码有错误,可以继续通过prompt交互来修改代码,然后,点击生成的代码右上角的 【Apply】按钮,就能将生成的代码填充到文件中。

EEZot4ms2的博客 450

手把手教你玩转AT32F403A位带操作:像51单片机一样控制GPIO

本文详细介绍了如何在雅特力AT32F403A国产MCU上实现位带操作,像51单片机一样高效控制GPIO。通过实战演示和性能对比,展示了位带操作在实时控制中的优势,包括更快的执行速度和更低的延迟,特别适合工业控制和电机驱动等场景。

weixin_29234509的博客 287

冀【Linux 进程控制】—— 进程亦生生不息:起于鸿蒙,守若空谷,归于太虚c

双缓冲(Double Buffer)是一种图形渲染中的常用技术,通过使用两个缓冲区(前台缓冲区和后台缓冲区)来解决图形渲染过程中的闪烁和撕裂问题。双缓冲的核心原理是:一个缓冲区用于当前显示的帧(前台缓冲区),另一个缓冲区用于绘制新帧(后台缓冲区)。:Unity早期版本使用内置渲染管线,双缓冲主要通过命令缓冲区(CommandBuffer)实现,开发者可以手动管理渲染目标的切换。URP使用SwapBufferSystem维护两个渲染目标缓冲区(m_A和m_B),在渲染过程中交替使用,避免中间环节的重复拷贝。

xslf1m9tF的博客 545

STM32CubeMX最新版下载安装全攻略(附官网访问问题解决方案)

本文提供了STM32CubeMX最新版的详细下载与安装指南,并针对国内开发者常见的官网访问缓慢、注册验证邮件延迟等问题,给出了实用的解决方案和备选策略。通过清晰的步骤解析,帮助用户快速部署这一强大的STM32图形化配置工具,从而高效启动嵌入式开发项目。

weixin_28256233的博客 197

Frida实战:高效dump Android内存中的so文件与修复技巧

本文详细介绍了使用Frida工具dump Android内存中已解密so文件的实战技巧。针对加固应用静态分析失效的痛点,文章提供了从环境搭建、使用frida_dump脚本自动化抓取内存数据,到利用SoFixer工具修复ELF文件结构的完整流程,帮助逆向分析人员高效获取可分析的so文件。

tt34567的博客 529

Linux 网络排障实战:工业边缘场景下的 ss 与 netsta

工业网关的网络问题 — 服务起不来、连接堆积、外联异常 — 大多能从 socket 状态入手定位。;netstat 属于已停止维护的 net-tools,本文仅作对照。从工程实战角度梳理连接排查的完整用法。

ZenovaEdgeOS的博客 458

Verilog HDL 100道面试题及参考答案

在 Verilog HDL 中,参数(parameter)和宏定义(define)都可用于定义常量,但它们存在诸多不同之处。参数(parameter)是模块内部的常量定义,具有局部性。它在模块内部起作用,不同模块可以有同名的参数,且值可以不同。参数通常用于定义模块的一些配置信息,例如数据位宽、延迟时间等。参数的定义和使用是在模块的作用域内进行的,通过参数传递可以方便地对模块进行配置。endmodule在上述代码中,WIDTH是一个参数,用于定义加法器的位宽。通过改变WIDTH。

大模型大数据攻城狮的专栏 1737

Linux输入输出重定向与用户管理精要

本文系统梳理了Linux输入输出与用户组管理核心内容。输入输出部分涵盖字符设备与块设备区别、文件描述符、重定向与管道机制,重点解析2>&1等易错点;用户管理部分详解3A安全机制、用户分类、配置文件及常用命令(如useradd、passwd、sudo),强调权限最小化与安全审计。全文突出实践应用,适用于系统运维与考试复习。

2301_80092853的博客 644

AI人工智能与数据挖掘的技术融合趋势

我们的目的是搞清楚AI人工智能和数据挖掘是怎么融合在一起的,以及这种融合未来会有什么样的发展趋势。范围涵盖了这两种技术融合的原理、应用场景,还有未来可能面临的挑战。我们会先讲讲AI人工智能和数据挖掘是什么,它们之间有什么关系。然后说说它们融合的算法原理、数学模型。接着通过一个实际的项目案例,看看它们是怎么在实际中运用的。还会介绍一些它们的应用场景和相关工具。最后分析一下未来的发展趋势和挑战,并且总结学到的知识,提出一些思考题让大家思考。AI人工智能。

AI 领航者的博客 1367

MATLAB - 利用非线性模型预测控制(Nonlinear MPC)来控制四旋翼飞行器

本示例展示了如何利用非线性模型预测控制(MPC)为四旋翼飞行器设计一个跟踪轨迹的控制器。

机器人控制与仿真应用 4435

Linux的管道符与重定向符

在讲解具体符号前,必须先理解 Linux 进程处理数据的三个默认通道(文件描述符):重定向和管道的本质,就是改变这些数据流的默认指向。将命令原本要打印在屏幕上的结果,写入到文件中。示例:(将 目录的详细列表写入 ,屏幕不再显示)示例:(在 末尾新增一行日志)示例:(若权限不足, 报错会被写入 ,屏幕无显示)示例(推荐用 ):(安装过程中的正常提示和报错信息,统统存入 )示例(传统写法):(注意顺序:先把 stdout 指向文件,再把 stderr 指向 stdout 当前的位置)示例:(命令执行,但屏蔽

Yisitelz的博客 209

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

USB 技术系列 11 · USB Linux 驱动框架

本文系统解析Linux USB驱动框架,涵盖USB Core、HCD(xhci-hcd/dwc3)、类驱动(CDC/HID/Mass Storage)分层架构,详解usb_device_id匹配、probe/disconnect生命周期及Device Tree配置。结合RISC-V N300实战,揭示Host/Device双模式驱动开发核心逻辑,助力嵌入式BSP开发者掌握USB子系统全栈能力。

peter_pan_study的博客 291

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

linux用phytool测试mdio接口的phy芯片

【代码】linux用phytool测试mdio接口的phy芯片。

qq_26074053的博客 209

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

Linux动态 DMA 映射指南(翻译版)

本文为设备驱动开发者提供动态DMA映射指南,涵盖虚拟、物理与总线地址差异,明确可DMA内存类型及寻址限制。介绍一致性与流式映射的使用场景与API,强调方向设置、错误处理及平台对齐要求。通过伪代码示例说明dma_set_mask、dma_alloc_coherent、dma_map_single等核心接口,确保高效安全的DMA操作。附录列明贡献者名单,术语解释涵盖IOMMU、TLB、MMIO等关键概念。

ZZXTIANMING的博客 248

【Linux】35:应用层自定义协议和序列化

本文实现了一个基于TCP字节流的网络计算器,通过自定义协议(长度头+JSON)解决粘包问题。核心在于应用层协议设计:使用Jsoncpp进行序列化与反序列化,以“长度\r\nJSON报文\r\n”格式封装数据,确保读取完整性。服务端采用多进程模型(二次fork)处理并发请求,客户端循环输入并发送请求,服务端计算后返回结果。项目融合了Socket编程、多进程、策略模式日志、RAII锁等技术,完整演示了从底层通信到高层业务的全栈实现。

qq_62473190的博客 112

Instabox 云端 Linux 虚拟机配置中文拼音输入法

Fcitx5 和拼音已安装、桌面会话加载了输入法环境变量、Fcitx 当前处于激活状态。在这次 Debian + XFCE 排查中,拼音本来已经安装;问题出在桌面会话没有正确加载变量,而且 Fcitx 需要再次激活。配置登录环境并执行后,当前输入法显示为pinyin,中文输入恢复正常。

binweisili的博客 142

WebStorm Linux 版安装实战与核心效能展示

本文系统介绍WebStorm在Linux(Ubuntu、Deepin、Fedora)上的安装部署与核心功能实战,涵盖环境适配、多方式安装、启动优化、智能补全、内置终端、Git集成、调试重构、远程开发及性能调优。结合真实开源项目重构案例,展示其在大型前端项目中的高效性,并提供常见问题排查与硬件配置建议,助力开发者实现从零到高效的全流程使用。

独坐一隅,凝神遐想,是种幸福! —— 独隅 467

【Linux】gdb调试

GDB是Linux下主流的命令行调试器,需编译时加-g生成调试符号,配合-O0关闭优化以确保源码与指令一一对应。通过设置断点、单步执行(n/s)、查看变量(p)、调用栈(bt)等命令,可精准追踪程序运行状态,定位逻辑错误。实战中,从编译到启动GDB、设断点、逐步调试直至退出,形成完整调试流程。掌握GDB是C/C++开发者必备技能,尤其在分析崩溃core文件和优化相关bug时至关重要。

2603_95853495的博客 284

Linux 常用命令 + GCC 编译全流程详解

本文为Linux与C语言初学者打造的实战指南,涵盖命令行核心技能:从文件操作、权限管理到查找、进程控制、打包压缩,最终深入剖析GCC编译四阶段(预处理、编译、汇编、链接),揭示gcc hello.c -o hello背后的完整流程。通过建立“一切皆文件”“命令即程序”等心智模型,帮助读者在纯命令行下完成代码开发全闭环,真正理解底层机制,适用于面试准备、跨平台开发及服务器部署场景。

2401_88413914的博客 308

Windows 下 QEMU 搭建 ARM64 Linux 开发环境完整教程 | 保姆级步骤 + SSH 远程登录

本文针对嵌入式开发、跨架构软件测试、ARM Linux 学习的开发者,提供一套在 Windows x86 电脑上零成本搭建 ARM64 虚拟机的完整方案。全程使用开源工具,覆盖环境安装、系统部署、远程登录、性能优化全流程,新手可直接照着步骤操作。

wutu_csdn_blog的博客 332

嵌入式 Linux OOM Killer 触发逻辑与防误杀实战指南

本文深入解析嵌入式 Linux 下 OOM Killer 的触发机制,结合工业网关真实工程场景,提供从日志排查、内核参数调优到关键进程保护的完整落地方案,解决核心进程被误杀导致的业务中断问题。

嵌入式扫地僧 430

华为平板直接跑 Linux 了:MatePad Edge 预置开发引擎,鸿蒙把边界又推远了一步

华为 MatePad Edge 鸿蒙 7.0 更新预置融合开发引擎,电脑模式原生跑 Linux,平板生产力再进一步。

mihuyang的博客 183

Linux epoll 一篇讲透:从 select/poll 到红黑树、LT/ET,再到完整 TCP 服务器

一万个客户端已经连上服务器,眼下只有十个客户端发来了数据。服务器怎样把时间花在这十个连接上?理解这个问题,就抓住了 epoll 的主线。接下来,我们沿着“为什么需要它 → 接口怎么用 → 内核如何实现 → LT/ET 怎么写 → 完整服务器怎么运行”的顺序,把知识连起来。**阅读基础:**了解socketbindlistenaccept的基本用途即可。本文示例面向 Linux,服务器使用 C++17,实验脚本使用 Python 3。

2601_94861874的博客 492

Linux FFmpeg深度解析之avio_read调用流程与实战(五十一)

本篇目的:理解如何从读取指定数量的数据,分析缓冲区和底层读取回调的协作过程,并通过文件读取示例观察返回值。是FFmpeg的输入输出抽象,承载文件、网络或自定义协议的数据读取。从这个上下文中读取字节到调用者提供的缓冲区。它负责字节读取,不负责解析容器、解码音视频或分配调用者的目标缓冲区。fill:#333;important;important;fill:none;color:#333;color:#333;important;fill:none;fill:#333;height:1em;

Android系统攻城狮 437

02 Linux 基础环境:Shell 命令行操作

正则表达式(Regular Expression,简称 Regex)是一种用于描述字符串匹配规则的表达式。它可以用于:搜索指定格式的文本。提取日志中的关键信息。验证字符串格式。批量替换文本。分析程序运行日志。在 Linux 中,grepsed和awk都支持不同形式的正则表达式。进程(Process)是程序运行时的实例。程序是存储在磁盘中的可执行文件,而进程是程序运行后由操作系统创建并管理的执行实体。每个进程通常具有:PID:进程 ID。PPID:父进程 ID。UID:进程所属用户。

2301_76633800的博客 277
上一篇: 【C++ 多态】—— 礼器九鼎,釉下乾坤,多态中的 “风水寻龙诀“
一整颗红豆
博客等级 码龄3年 6024粉丝 44原创
评论 114
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一整颗红豆

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值