【嵌入式Linux应用开发基础】fork()函数

目录

一、fork 函数概述

1.1. 函数作用

1.2. 函数原型与头文件

1.3. 返回值

1.4. 核心特性

二、父子进程的区别与联系

2.1. 相同点

2.2. 不同点

三、典型应用场景

3.1. 多任务处理

3.2. 守护进程创建

3.3. 执行外部程序

3.4. 并行计算

四、fork 函数的关键注意事项

4.1. 返回值处理

4.2. 执行顺序不确定性

4.3. 资源继承

4.4. 僵尸进程处理

4.5. 多线程环境下的风险

4.6. 信号处理

4.7. 内存与资源的独立性

4.8. 性能影响

4.9. 错误处理

4.10. 替代函数

---

在嵌入式 Linux 应用开发中，fork 函数是一个至关重要的系统调用，用于创建新进程。它允许一个进程（父进程）创建一个与自身几乎完全相同的副本（子进程）。这两个进程（父进程和子进程）在 fork 调用之后，将各自执行后续代码，但具有不同的执行路径。

一、fork 函数概述

1.1. 函数作用

fork 函数通过复制调用它的进程来创建一个新进程。具体来说，内核为新进程分配新的进程控制块（PCB），并复制父进程的地址空间、打开的文件描述符、信号处理函数等资源。子进程从 fork 调用处开始执行，与父进程并发运行。然而，子进程和父进程在进程ID和fork函数的返回值上有所不同。

1.2. 函数原型与头文件

fork 函数的原型如下：

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

1.3. 返回值

fork 函数返回一个 pid_t 类型的值，该值有三种情况：

• 在父进程中：fork函数返回新创建的子进程的进程ID（PID）。父进程可以通过这个 PID 来识别和管理子进程。
• 在子进程中：fork函数返回0。子进程可以通过检查返回值为 0 来确定自己是子进程。
• 出错时：fork函数返回-1，并设置全局变量errno以指示错误原因。常见的错误原因包括系统资源不足（如内存不足）等。

1.4. 核心特性

• 写时复制（Copy-on-Write, CoW））：内存仅在写入时复制，提升效率。

• 独立执行流：父子进程并发执行，顺序由调度器决定。

• 文件描述符共享：子进程继承父进程打开的文件，需注意同步。

二、父子进程的区别与联系

2.1. 相同点

• 子进程继承了父进程的大部分属性，如用户 ID、组 ID、环境变量、当前工作目录、文件描述符等。意味着子进程在很多方面与父进程具有相似的运行环境。

• 子进程从父进程处复制了地址空间，包括代码段、数据段、堆和栈等。因此，子进程在 fork 调用之后，看起来和父进程执行相同的代码。

2.2. 不同点

• 进程 ID（PID）：父进程和子进程具有不同的 PID。父进程可以通过 fork 的返回值获取子进程的 PID，而子进程可以通过 getpid 函数获取自己的 PID，通过 getppid 函数获取父进程的 PID。

• 返回值：fork 函数在父进程和子进程中返回不同的值，这是区分父子进程的关键。

• 资源使用：虽然子进程复制了父进程的资源，但在实际运行中，父子进程对资源的使用是相互独立的。例如，父子进程对全局变量的修改不会相互影响，因为它们有各自独立的地址空间。不过，对于共享资源（如打开的文件描述符），父子进程需要协调使用，以避免数据竞争和不一致。

三、典型应用场景

3.1. 多任务处理

在需要同时执行多个任务的场景下，fork 函数可用于创建子进程，让每个进程独立执行不同的任务，实现并发操作，提高系统整体效率。

①网络服务器：网络服务器通常需要同时处理多个客户端的请求。主进程可以作为监听进程，负责接收客户端的连接请求。每当有新的连接到来时，主进程调用 fork 创建一个子进程来专门处理该客户端的请求，而主进程继续监听新的连接。这样，服务器可以同时处理多个客户端，提高响应速度和并发处理能力。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>

#define PORT 8080

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);

    // 创建套接字
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // 设置套接字选项
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
        perror("setsockopt");
        exit(EXIT_FAILURE);
    }
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // 绑定套接字
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
    // 监听连接
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    while (1) {
        if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
            perror("accept");
            continue;
        }
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork failed");
        } else if (pid == 0) {
            // 子进程处理客户端请求
            close(server_fd);
            // 处理客户端请求的代码
            close(new_socket);
            exit(EXIT_SUCCESS);
        } else {
            // 父进程继续监听新连接
            close(new_socket);
        }
    }
    return 0;
}

②嵌入式系统中的数据采集与处理：在嵌入式设备中，一个进程可以负责从传感器采集数据，另一个进程可以对采集到的数据进行处理和分析。主进程创建一个子进程负责数据采集，主进程则专注于数据处理，两个进程并发执行，提高系统的数据处理效率。

3.2. 守护进程创建

守护进程是在后台运行的进程，通常在系统启动时启动，一直运行直到系统关闭，用于执行系统级任务，如日志记录、系统监控等。fork 函数是创建守护进程的关键步骤之一。

日志记录守护进程：系统需要记录各种事件和操作的日志，以方便后续的问题排查和系统分析。可以通过 fork 创建守护进程，让其在后台不断监听系统事件，并将相关信息记录到日志文件中。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

void create_daemon() {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    }
    if (pid > 0) {
        // 父进程退出
        exit(EXIT_SUCCESS);
    }
    // 子进程继续执行
    // 创建新会话
    if (setsid() < 0) {
        perror("setsid failed");
        exit(EXIT_FAILURE);
    }
    // 改变工作目录
    if (chdir("/") < 0) {
        perror("chdir failed");
        exit(EXIT_FAILURE);
    }
    // 设置文件掩码
    umask(0);
    // 关闭标准输入、输出和错误输出
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);

    // 守护进程的工作逻辑，例如日志记录
    while (1) {
        // 日志记录代码
        sleep(1);
    }
}

int main() {
    create_daemon();
    return 0;
}

3.3. 执行外部程序

在某些情况下，需要在程序中启动外部程序来完成特定功能。可以通过 fork 创建子进程，然后在子进程中使用 exec 系列函数来执行外部程序。

系统命令调用：在编写脚本或工具时，可能需要调用系统命令来完成某些操作，如文件压缩、进程管理等。通过 fork 创建子进程，在子进程中使用 exec 函数执行相应的系统命令。

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

int main() {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程执行外部程序
        char *args[] = {"ls", "-l", NULL};
        if (execvp("ls", args) == -1) {
            perror("execvp failed");
            exit(EXIT_FAILURE);
        }
    } else {
        // 父进程等待子进程结束
        wait(NULL);
    }
    return 0;
}

3.4. 并行计算

在进行大规模数据处理或复杂计算时，可以利用 fork 创建多个子进程，将任务分解到不同的进程中并行执行，以加快计算速度。

数值计算：例如，计算一个大型矩阵的乘法，可以将矩阵分成多个子矩阵，每个子进程负责计算一部分子矩阵的乘积，最后将结果合并。

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

#define MATRIX_SIZE 100
#define NUM_PROCESSES 4

// 矩阵乘法函数
void matrix_multiplication(int start, int end) {
    // 执行矩阵乘法的代码
    for (int i = start; i < end; i++) {
        for (int j = 0; j < MATRIX_SIZE; j++) {
            // 计算矩阵元素
        }
    }
}

int main() {
    pid_t pid;
    int i;
    int chunk_size = MATRIX_SIZE / NUM_PROCESSES;

    for (i = 0; i < NUM_PROCESSES; i++) {
        pid = fork();
        if (pid < 0) {
            perror("fork failed");
            exit(EXIT_FAILURE);
        } else if (pid == 0) {
            int start = i * chunk_size;
            int end = (i == NUM_PROCESSES - 1) ? MATRIX_SIZE : (i + 1) * chunk_size;
            matrix_multiplication(start, end);
            exit(EXIT_SUCCESS);
        }
    }

    // 父进程等待所有子进程结束
    for (i = 0; i < NUM_PROCESSES; i++) {
        wait(NULL);
    }

    return 0;
}

四、fork 函数的关键注意事项

4.1. 返回值处理

• 父进程：返回子进程的 PID（>0）。

• 子进程：返回 0。

• 错误：返回 -1（如进程数达到上限、内存不足）。

pid_t pid = fork();
if (pid == -1) {
    // 处理错误
} else if (pid == 0) {
    // 子进程代码
} else {
    // 父进程代码
}

注意：必须检查返回值，否则可能导致逻辑错误或资源泄漏。 

4.2. 执行顺序不确定性

• 父子进程的执行顺序由调度器决定，不能假设谁先运行。

• 解决方案：如需同步，使用 waitpid()、信号量或管道等机制。

4.3. 资源继承

• 子进程复制父进程的：

  • 内存（代码、数据、堆栈，通过 写时复制 优化）。

  • 打开的文件描述符（共享同一文件偏移量，可能导致写入竞争）。

  • 信号处理函数、进程组、会话、环境变量等。

• 关键问题：

  • 文件描述符需及时关闭（如网络套接字），避免资源泄漏。

  • 使用 O_CLOEXEC 标志打开文件，确保 exec 后自动关闭。

4.4. 僵尸进程处理

• 子进程终止后：若父进程未调用 wait()/waitpid()，子进程将变为僵尸进程（占用系统资源）。

• 解决方案：

  • 父进程主动回收子进程状态。

  • 使用信号 SIGCHLD 处理函数异步回收。

4.5. 多线程环境下的风险

• fork() 仅复制调用线程，其他线程在子进程中“消失”。

• 风险：若父进程其他线程持有锁，子进程可能死锁或数据不一致。

• 建议：

  • 在 fork() 后立即调用 exec() 执行新程序（避免执行复杂逻辑）。

  • 避免在多线程程序中直接使用 fork()。

4.6. 信号处理

• 子进程继承父进程的信号处理函数，但未决信号会被清空。

• 注意：子进程可能需要重新设置信号处理逻辑。

4.7. 内存与资源的独立性

• 父子进程的内存修改互不影响（因写时复制机制）。

• 例外：共享的文件描述符（如管道、套接字）会影响彼此。

4.8. 性能影响

• 频繁 fork() 可能导致性能问题（即使有写时复制）。

• 替代方案：考虑使用线程池或 posix_spawn()。

4.9. 错误处理

• 检查 fork() 是否失败（如返回 -1），防止后续逻辑错误。

if (pid == -1) {
    perror("fork failed");
    exit(EXIT_FAILURE);
}

4.10. 替代函数

• vfork()：创建子进程但不复制内存，子进程必须立即调用 exec() 或 _exit()（已逐渐被废弃）。

• posix_spawn()：更安全、高效地创建新进程（封装了 fork() + exec()）。

总之，fork 函数是嵌入式 Linux 应用开发中实现进程控制和多任务处理的重要工具。深入理解其原理、使用方法及注意事项，对于开发高效、稳定的嵌入式系统至关重要。

---