Linux 进程创建与终止全解析：fork 原理 + 退出机制实战

🔥草莓熊Lotso：个人主页

❄️个人专栏: 《C++知识分享》 《Linux 入门到实践：零基础也能懂》

✨生活是默默的坚持，毅力是永久的享受！

🎬 博主简介：

文章目录

• 前言：
• 一. 进程创建：fork 函数的底层逻辑与实战
• • 1.1 fork 函数基础用法
  • 1.2 fork 的底层工作流程
  • 1.3 写时拷贝技术：父子进程的 “分离术”
  • 1.4 fork 的常见用法与失败场景
• 二. 进程终止：资源释放与退出机制
• • 2.1 进程退出的三种场景
  • 2.2 进程终止的三种方法
  • 2.3 退出码：进程的 “执行结果报告”
• 结尾：

前言：

在 Linux 多任务编程中，进程的创建与终止是最基础也是最核心的操作。 fork 函数是创建新进程的 “入口”，而进程终止则涉及资源释放、退出码传递等关键逻辑 — 理解这两个过程，能帮你打通进程管理的底层思维，避免僵尸进程、资源泄漏等常见问题。本文从 fork 函数的工作原理、写时拷贝技术，到进程终止的场景、方法与退出码解析，层层递进拆解核心逻辑，搭配实战代码帮你彻底掌握。

一. 进程创建：fork 函数的底层逻辑与实战

fork函数是 Linux 创建新进程的核心系统调用，它从已存在的进程（父进程）中复制出一个新进程（子进程），父子进程各自独立执行后续逻辑。

1.1 fork 函数基础用法

#include <unistd.h>
pid_t fork(void);

返回值规则（关键！）：

• 子进程中返回 0；
• 父进程中返回 子进程的 PID（进程唯一标识）；
• 调用失败返回 -1（如系统进程数达到上限）。

（2）三个关键问题解答（之前就解答到过了）：

1.2 fork 的底层工作流程

进程调用fork，当控制转移到内核中的fork代码后，内核会执行以下步骤：

• 为子进程分配新的内存块和内核数据结构（如task_struct、页表）；
• 将父进程的部分数据结构（如进程属性、文件描述符）拷贝至子进程；
• 将子进程添加到系统进程列表，使其成为可调度进程；
• 从fork返回，调度器开始调度父子进程（谁先执行由调度器决定，无固定顺序）。

1.3 写时拷贝技术：父子进程的 “分离术”

（1）核心原理 fork创建子进程时，并不会立即复制父进程的所有数据（代码段、数据段），而是让父子进程共享这些资源，仅当任意一方试图写入数据时，才会触发 “写时拷贝”（Copy-On-Write），为写入方分配独立的副本。

（2）优势

• 延迟分配内存，提高整机内存利用率（若子进程仅读取数据，无需额外分配内存）；
• 加速fork调用速度（避免大量数据拷贝）；
• 保证进程独立性（写入时自动分离，互不干扰）。 （3）代码验证写时拷贝

#include <stdio.h>
#include <unistd.h>

int g_val = 10; // 全局变量，初始父子共享

int main() {
pid_t pid = fork();
if (pid == –1)
{
perror("fork failed");
return 1;
}
else if (pid == 0)
{ // 子进程
g_val = 20; // 触发写时拷贝
printf("子进程：pid=%d，g_val=%d，地址=%p\\n", getpid(), g_val, &g_val);
}
else
{ // 父进程
sleep(1); // 等待子进程修改完成
printf("父进程：pid=%d，g_val=%d，地址=%p\\n", getpid(), g_val, &g_val);
}
return 0;
}

输出结果：

子进程：pid=12345，g_val=20，地址=0x80497e8
父进程：pid=12344，g_val=10，地址=0x80497e8

• 现象：父子进程中g_val地址相同（虚拟地址，这里之前讲过），但值不同；
• 结论：写时拷贝触发后，子进程获得独立的数据副本，实现进程分离。

1.4 fork 的常见用法与失败场景

（1）典型用法

• 父子进程执行不同代码段（如父进程创建数据，子进程进行备份）；
• 子进程通过exec函数替换为新程序（后续文章详解）。

（2）调用失败原因

• 系统进程数达到上限（可通过ulimit -u查看进程数限制）；
• 实际用户的进程数超过系统配置上限。

实际场景演示（备份）：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#define NUM 10

int data[NUM] = {0};

void Backup()
{
pid_t id = fork();
if (id == 0)
{
// child
int i = 0;
printf("Backup: ");
for (i = 0; i < NUM; i++)
{
printf("%d ", data[i]);
}
printf("\\n");
sleep(10);
exit(0); // 进程结束
}
}

void ChangeData()
{
int i = 0;
for (; i < NUM; i++)
{
data[i] = i + rand();
}
printf("origin data: ");
for (i = 0; i < NUM; i++)
{
printf("%d ", data[i]);
}
printf("\\n");
}

int main()
{
srand(time(NULL));
while (1)
{
// 修改
ChangeData();
// 备份
Backup();
sleep(5);
}
}

时间线：
1. 父进程修改 data → [新值1, 新值2, ...]
2. fork() 创建子进程，复制当前 data
3. 子进程打印：[新值1, 新值2, ...] ← 备份成功
4. 父进程继续循环，5秒后再次修改 data
5. 创建新的子进程备份新数据...

核心逻辑：

结果：每次父进程修改数据时，都会创建一个子进程来保存修改前的数据副本。 注意：这个程序会不断创建子进程但从不回收，可能导致僵尸进程累积，我们后面会讲进程等待的，这里先不管它。

二. 进程终止：资源释放与退出机制

进程终止的本质是释放进程占用的系统资源（内核数据结构、内存、文件描述符等），并将退出状态反馈给父进程。

2.1 进程退出的三种场景

• 正常终止：代码运行完毕，结果正确（如main函数返回0）；
• 正常终止但结果错误：代码运行完毕，但逻辑错误（如main函数返回1）；
• 异常终止：代码运行中遇到错误（如除零、段错误、信号终止）。

2.2 进程终止的三种方法

（1）从 main 函数返回（最常用） return n 等同于调用 exit(n)，n 为进程退出码（0表示成功，非0表示失败）。

// 正常退出，退出码 0
int main()
{
printf("程序正常执行完毕\\n");
return 0;
}

正常退出，可以使用 echo $? 查看进程退出码

（2）调用 exit 函数（标准库函数） exit 会在终止进程前执行清理工作，最终调用_exit系统调用(_exit 不会主动刷新缓冲区)。

#include <stdio.h>
#include <stdlib.h>

int main()
{
printf("执行exit退出\\n");
exit(1); // 退出码1，标识执行失败,也可以使用其他的退出码
}

（3）调用_exit 函数（系统调用） _exit 直接终止进程，不执行任何清理工作，速度更快。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
printf("执行_exit退出");
// 故意不带 \\n,体会刷没刷新缓冲区
_exit(1); // 退出码1，标识执行失败,也可以使用其他的退出码
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

// exit会冲刷缓存，输出"hello"
void TestExit()
{
printf("hello");
exit(0);
}

// _exit不冲刷缓存，无输出
void Test_Exit()
{
printf("hello");
_exit(0);
}

int main()
{
// 分别调用一下进行测试看看输出结果
TestExit();
//Test_Exit();
return 0;
}

（4）异常终止（信号触发） 通过Ctrl+C（SIGINT 信号）、kill -9 进程PID（SIGKILL 信号）等方式终止进程，属于异常退出。

2.3 退出码：进程的 “执行结果报告”

退出码是进程终止时反馈给父进程的 “状态信息”，核心规则：

• 退出码 0：执行成功；
• 退出码 1~255：执行失败（不同数值可标识不同错误类型）；
• 父进程可通过 wait/waitpid 获取子进程退出码（后续文章详解）；
• 终端中通过 echo $? 查看最近一次执行程序的退出码。

通过 strerror 获取退出码描述：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main()
{
int exit_code = 1;
printf("退出码%d：%s\\n", exit_code, strerror(exit_code));
return 0;
}

注意： 退出码仅低 8 位有效：_exit(-1) 等价于 _exit(255)（-1 & 0xFF = 255）；

常见误区澄清：

• fork 后父子进程共享所有数据：错误！代码段共享，但数据段采用写时拷贝，写入时自动分离；
• exit 和_exit 完全一致：错误！exit 会冲刷缓存、执行清理函数，_exit 直接终止；
• 退出码可以是任意整数：错误！仅低 8 位有效，超过 255 会自动取模（如exit(300)等价于exit(44)）；
• 子进程退出后资源会自动释放：错误！需父进程调用wait/waitpid回收，否则会变成僵尸进程。

结尾：

🍓 我是草莓熊 Lotso！若这篇技术干货帮你打通了学习中的卡点：
👀 【关注】跟我一起深耕技术领域，从基础到进阶，见证每一次成长
❤️ 【点赞】让优质内容被更多人看见，让知识传递更有力量
⭐ 【收藏】把核心知识点、实战技巧存好，需要时直接查、随时用
💬 【评论】分享你的经验或疑问（比如曾踩过的技术坑？），一起交流避坑
🗳️ 【投票】用你的选择助力社区内容方向，告诉大家哪个技术点最该重点拆解
技术之路难免有困惑，但同行的人会让前进更有方向～愿我们都能在自己专注的领域里，一步步靠近心中的技术目标！

结语：进程创建（fork）和终止是 Linux 进程管理的基础，核心要点：fork通过写时拷贝实现高效创建，进程终止需关注资源释放和退出码传递。理解这些逻辑，能帮你规避僵尸进程、资源泄漏等问题，为后续学习进程等待、程序替换打下基础。本文覆盖了fork和进程终止的核心知识点，搭配实战代码可直接上手验证。如果需要深入学习进程等待（wait/waitpid）或程序替换（exec函数簇），可以期待一下后续文章。

✨把这些内容吃透超牛的！放松下吧✨

ʕ˘ᴥ˘ʔ

づきらど