Linux 进程创建与终止：fork 与 exit 底层逻辑解析

利用返回值可让父子进程执行不同代码：

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

int main(void) {
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        exit(1);
    } else if (pid == 0) {
        printf("我是子进程，PID：%d，父进程 PID：%d\n", getpid(), getppid());
        sleep(3);
        exit(0);
    } else {
        printf("我是父进程，PID：%d，创建的子进程 PID：%d\n", getpid(), pid);
        sleep(5);
    }
    return 0;
}

1.3 写时拷贝

Linux 采用**写时拷贝（Copy-On-Write, COW）**优化技术。父子进程初始共享内存资源，标记为'只读'。只有当一方试图修改数据时，内核才分配新内存并拷贝数据。

工作流程：

1. fork 后虚拟内存页表指向相同物理内存页，设为只读。
2. 尝试修改时触发写保护异常。
3. 内核分配新物理页，拷贝原数据。
4. 更新页表指向新页，取消只读限制。

优势：提高创建效率，节省内存资源。

验证代码（cow_demo.c）：

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

int g_val = 10;

int main(void) {
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        exit(1);
    } else if (pid == 0) {
        printf("子进程：初始 g_val = %d，地址 = %p\n", g_val, &g_val);
        g_val = 20;
        printf("子进程：修改后 g_val = %d，地址 = %p\n", g_val, &g_val);
    } else {
        sleep(1);
        printf("父进程：g_val = %d，地址 = %p\n", g_val, &g_val);
    }
    return 0;
}

1.4 fork 常规用法

用法一：父子进程执行不同代码段

用于并发处理场景。父进程监听任务，子进程处理任务。

示例代码（server_fork_demo.c）：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#define PORT 8080
#define BACKLOG 5

void handle_client(int client_fd) {
    char buf[1024] = {0};
    ssize_t n = read(client_fd, buf, sizeof(buf));
    if (n > 0) {
        printf("子进程（PID：%d）收到客户端数据：%s\n", getpid(), buf);
        write(client_fd, "收到你的消息啦！", strlen("收到你的消息啦！"));
    }
    close(client_fd);
    exit(0);
}

int main(void) {
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd == -1) {
        perror("socket failed");
        exit(1);
    }
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    addr.sin_addr.s_addr = INADDR_ANY;
    if (bind(listen_fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        perror("bind failed");
        exit(1);
    }
    if (listen(listen_fd, BACKLOG) == -1) {
        perror("listen failed");
        exit(1);
    }
    printf("父进程（PID：%d）监听端口 %d...\n", getpid(), PORT);
    while (1) {
        struct sockaddr_in client_addr;
        socklen_t client_len = sizeof(client_addr);
        int client_fd = accept(listen_fd, (struct sockaddr*)&client_addr, &client_len);
        if (client_fd == -1) {
            perror("accept failed");
            continue;
        }
        pid_t pid = fork();
        if (pid == -1) {
            perror("fork failed");
            close(client_fd);
            continue;
        } else if (pid == 0) {
            close(listen_fd);
            handle_client(client_fd);
        } else {
            close(client_fd);
        }
    }
    close(listen_fd);
    return 0;
}

用法二：子进程调用 exec 函数

结合 exec 函数族替换代码段，执行全新程序。这是 shell 命令执行的核心原理。

示例代码（exec_fork_demo.c）：

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

int main(void) {
    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        exit(1);
    } else if (pid == 0) {
        printf("子进程（PID：%d）执行 ls 命令...\n", getpid());
        char *const argv[] = {"ls", "-l", NULL};
        execvp("ls", argv);
        perror("execvp failed");
        exit(1);
    } else {
        wait(NULL);
        printf("父进程（PID：%d）：子进程执行完成\n", getpid());
    }
    return 0;
}

1.5 fork 调用失败原因

1. 系统进程数过多：达到内核最大进程数限制（/proc/sys/kernel/pid_max）。
2. 用户进程数超限：超过 RLIMIT_NPROC 限制（ulimit -u）。
3. 内存不足：无法分配 PCB 或页表等内核数据结构。

失败时可调用 perror 打印错误信息。

二、进程终止

2.1 进程退出场景

1. 代码运行完毕，结果正确：退出码为 0。
2. 代码运行完毕，结果不正确：返回非 0 退出码。
3. 代码异常终止：收到致命信号或触发严重错误。

2.2 进程退出方法

2.2.1 正常终止

1. 从 main 函数返回（return）：等同于调用 exit。
2. 调用 exit 函数：标准库函数，会执行清理函数、刷新缓冲区。
3. 调用_exit 函数：系统调用，直接终止，不执行清理函数，不刷新缓冲区。

exit 与_exit 区别示例：

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

int main(void) {
    printf("exit 函数：");
    exit(0);
    // printf("_exit 函数：");
    // _exit(0);
}

2.2.2 异常终止

1. 用户发送信号：如 Ctrl+C 发送 SIGINT。
2. kill 命令发送信号：如 kill -9 发送 SIGKILL。
3. 致命错误：如除零错误触发 SIGFPE。

异常终止退出码通常为 128 + 信号编号。

2.2.3 退出码详解

退出码范围 0-255。

• 0：成功。
• 1-255：失败或特定错误类型。
• 128+n：被信号 n 终止。

常见退出码含义：

可通过 $? 获取上一个进程退出码。

总结

本文介绍了 Linux 下进程创建与终止的核心机制。重点讲解了 fork 函数的特性及返回值含义，阐述了写时拷贝优化原理。对比了 exit 与_exit 函数的区别，分析了正常终止与异常终止的场景及退出码规则。通过 C 语言代码示例演示了父子进程协作、exec 替换及常见错误处理，帮助理解进程生命周期管理。