【嵌入式Linux应用开发基础】特殊进程-EW帮帮网

创建子进程，父进程退出：通过fork()函数创建子进程，然后父进程使用exit()函数退出。这样，子进程将变成一个孤儿进程，被init进程（PID为1的进程）收养。这一步实现了子进程与父进程的脱离，使得子进程可以在后台运行。
在子进程中创建新的会话：使用setsid()函数创建一个新的会话，并设置进程的会话ID。这一步使得子进程成为新会话的会话领导者，并摆脱原会话、进程组和控制终端的控制。
更改当前工作目录：通常将守护进程的当前工作目录更改为根目录“/”，以避免因文件系统卸载而导致的问题。
重设文件权限掩码：将文件权限掩码设置为0，以确保守护进程具有最大的文件操作权限。
关闭所有打开的文件描述符：关闭从父进程继承的所有打开文件，以避免资源泄漏和文件系统无法卸载的问题。通常将标准输入、标准输出和标准错误重定向到/dev/null，使得守护进程的输出无处显示，也无处从交互式用户那里接收输入。

1.5. 守护进程的实例

以下是一个简单的守护进程创建实例：

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

int main() {
    pid_t pid;
    int i;

    // 第一步：创建子进程，父进程退出
    pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(1);
    } else if (pid > 0) {
        exit(0); // 父进程退出
    }

    // 第二步：在子进程中创建新的会话
    if (setsid() < 0) {
        perror("setsid");
        exit(1);
    }

    // 第三步：更改当前工作目录
    if (chdir("/") < 0) {
        perror("chdir");
        exit(1);
    }

    // 第四步：重设文件权限掩码
    umask(0);

    // 第五步：关闭所有打开的文件描述符
    for (i = 0; i < sysconf(_SC_OPEN_MAX); i++) {
        close(i);
    }

    // 重定向标准输入、标准输出和标准错误到/dev/null
    open("/dev/null", O_RDWR);
    dup(0);
    dup(0);

    // 守护进程的主体工作
    while (1) {
        sleep(10); // 模拟守护进程的工作，每隔10秒执行一次任务
        // 在这里添加守护进程需要执行的任务代码
        printf("守护进程运行中...\n"); // 注意：这里的输出实际上会被重定向到/dev/null，因此不会在终端上显示
    }

    exit(0);
}

printf("守护进程运行中...\n");语句实际上并不会在终端上显示输出，因为守护进程的标准输出已经被重定向到/dev/null。在实际应用中，守护进程通常会执行一些后台任务，如监听网络请求、处理系统日志等。

1.6. 守护进程的管理

在Linux系统中，可以使用ps、top等命令来查看正在运行的守护进程。如果需要终止某个守护进程，可以使用kill命令向该进程发送SIGKILL或SIGTERM信号。此外，还可以使用nohup命令或&符号将命令放入后台运行，并使其具有一定的守护进程特性（尽管这并不是真正的守护进程）。

1.7. 影响与处理

守护进程可以提高系统的稳定性和可靠性，确保一些重要的服务始终处于运行状态。在开发守护进程时，需要注意资源管理和错误处理，避免守护进程出现异常导致系统不稳定。

二、僵尸进程（Zombie Process）

2.1. 僵尸进程的定义

在Linux系统中，僵尸进程是一种特殊的进程状态。当一个子进程已经完成执行（即已经终止），但其父进程尚未通过wait()或waitpid()系统调用来回收其资源和状态信息时，这个子进程就处于僵尸状态，被称为僵尸进程。

2.2. 僵尸进程的特点

进程状态：僵尸进程已经终止，不再执行任何任务，且所有资源（如CPU、内存等）都已释放。然而，它的进程描述符（PCB）仍然保留在系统中。
占用系统资源：尽管僵尸进程本身不占用CPU和内存等资源，但它仍然占用进程表中的一个条目，以及保留一定的信息（如进程号PID、退出状态等）。这些信息直到父进程调用wait()或waitpid()时才被释放。
无法被直接杀死：僵尸进程已经处于死亡状态，因此无法通过常规的信号（如SIGKILL）将其杀死。只能通过杀死其父进程或等待其父进程主动回收来间接清理僵尸进程。

2.3. 僵尸进程的产生原因

僵尸进程的产生通常是因为父进程没有正确地回收子进程的资源。当子进程退出后，它会发送一个SIGCHLD信号给父进程，通知父进程它已经结束。如果父进程没有处理这个信号或者没有调用wait()系列函数来清理子进程的状态，子进程就会变成僵尸进程。

以下是一个简单的示例代码，演示了僵尸进程的产生：

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

int main() {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程
        printf("Child process (PID: %d) is exiting.\n", getpid());
        exit(0);
    } else {
        // 父进程
        printf("Parent process (PID: %d) is running.\n", getpid());
        // 父进程不调用 wait() 或 waitpid()
        sleep(30); 
        printf("Parent process is exiting.\n");
    }
    return 0;
}

子进程先退出，但父进程在一段时间内没有调用 wait() 或 waitpid() 来回收子进程的资源，子进程就会变成僵尸进程。

2.4. 僵尸进程的影响

系统资源消耗：虽然僵尸进程本身不占用大量资源，但大量僵尸进程会占用进程表中的条目，可能导致进程表耗尽，从而无法创建新的进程。
系统性能问题：在资源有限的情况下，僵尸进程可能影响系统的管理和资源分配，进而导致系统性能下降。

2.5. 检测方法

可以使用以下命令来检测系统中的僵尸进程：

ps 命令：使用 ps -ef 或 ps aux 命令可以查看系统中所有进程的信息。僵尸进程在输出中会显示为 <defunct> 状态。例如：

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root      1234  0.0  0.0      0     0 ?        Z    10:00   0:00 [defunct]

其中，STAT 列显示为 Z 表示该进程是僵尸进程。

top 命令：运行 top 命令后，按下 Shift + Z 组合键，可以突出显示僵尸进程。僵尸进程会以特殊的颜色显示，方便用户识别。

2.5. 解决办法

为了避免僵尸进程的产生，父进程应该在子进程结束后及时回收其资源。可以采用以下几种方法：

①使用 wait() 函数：wait() 函数会使父进程阻塞，直到有一个子进程结束。父进程调用 wait() 后，会获取子进程的退出状态，并释放子进程的相关资源。示例代码如下：

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

int main() {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程
        printf("Child process (PID: %d) is exiting.\n", getpid());
        exit(0);
    } else {
        // 父进程
        int status;
        pid_t wpid = wait(&status);
        if (wpid > 0) {
            printf("Parent process reaped child process (PID: %d).\n", wpid);
        }
    }
    return 0;
}

②使用 waitpid() 函数：waitpid() 函数比 wait() 函数更加灵活，它可以指定要等待的子进程的 PID，也可以设置非阻塞模式。示例代码如下：

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

int main() {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程
        printf("Child process (PID: %d) is exiting.\n", getpid());
        exit(0);
    } else {
        // 父进程
        int status;
        pid_t wpid;
        do {
            wpid = waitpid(pid, &status, WNOHANG);
            if (wpid == 0) {
                // 子进程还未结束，父进程可以继续执行其他任务
                sleep(1);
            }
        } while (wpid == 0);

        if (wpid > 0) {
            printf("Parent process reaped child process (PID: %d).\n", wpid);
        }
    }
    return 0;
}

③信号处理：父进程可以通过捕获 SIGCHLD 信号，并在信号处理函数中调用 wait() 或 waitpid() 来回收子进程的资源。示例代码如下：

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

void sigchld_handler(int signum) {
    int status;
    pid_t pid;
    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
        printf("Reaped child process (PID: %d).\n", pid);
    }
}

int main() {
    // 注册 SIGCHLD 信号处理函数
    signal(SIGCHLD, sigchld_handler);

    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程
        printf("Child process (PID: %d) is exiting.\n", getpid());
        exit(0);
    } else {
        // 父进程
        while (1) {
            sleep(1);
        }
    }
    return 0;
}

三、孤儿进程（Orphan Process）

3.1. 定义

在 Linux 系统里，当一个子进程的父进程提前退出时，这个子进程就会变成孤儿进程。由于父进程已经不存在，孤儿进程会被 init 进程（进程 ID 为 1）收养，成为 init 进程的子进程。

3.2. 产生原因

孤儿进程通常是由于父进程在创建子进程后，未等待子进程结束就提前退出而产生的。这种情况可能出现在多种场景中，例如：

父进程完成了自身的任务后正常退出，而子进程仍在执行某些耗时的操作。
父进程因发生异常或错误而意外终止，导致子进程失去了父进程的管理。

以下是一个简单的代码示例，用于演示孤儿进程的产生：

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

int main() {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程
        printf("Child process (PID: %d) is running, parent PID: %d\n", getpid(), getppid());
        sleep(10); // 子进程休眠 10 秒
        printf("Child process (PID: %d) is still running, new parent PID: %d\n", getpid(), getppid());
    } else {
        // 父进程
        printf("Parent process (PID: %d) is exiting.\n", getpid());
        exit(0);
    }
    return 0;
}

父进程先退出，子进程在一段时间后才会继续执行后续代码。在父进程退出后，子进程的父进程 ID 会变为 1，即被 init 进程收养。

3.3. 特点

被 init 进程收养：孤儿进程会自动被 init 进程接管，init 进程会成为其新的父进程。init 进程会周期性地调用 wait() 系统调用来回收孤儿进程的资源，确保不会产生僵尸进程。
继续执行：孤儿进程并不会因为父进程的退出而终止，它会继续执行自己的任务，直到完成或被其他因素终止。
与控制终端失去关联：如果父进程与控制终端有关联，当父进程退出后，孤儿进程会与该控制终端失去关联，成为一个后台进程。

3.4. 影响

正常情况下无危害：在大多数情况下，孤儿进程本身不会对系统造成危害。由于 init 进程会负责回收孤儿进程的资源，所以不会出现资源泄漏的问题。
可能影响系统资源：如果系统中存在大量的孤儿进程，可能会消耗一定的系统资源，如进程表项和内存等。不过，这种情况通常比较少见，因为 init 进程会及时回收孤儿进程的资源。

3.5. 处理方式

无需特殊处理：一般来说，不需要对孤儿进程进行特殊的处理。init 进程会自动管理和回收孤儿进程的资源，确保系统的正常运行。
监控与调试：在开发和调试过程中，可以使用系统工具（如 ps、top 等）来监控孤儿进程的状态。例如，使用 ps -ef 命令可以查看系统中所有进程的信息，通过观察进程的父进程 ID 是否为 1 来判断是否为孤儿进程。

3.6. 实际应用场景

守护进程的创建：在创建守护进程时，通常会先创建一个子进程，然后让父进程退出，使子进程成为孤儿进程。接着，子进程再进行一系列操作（如创建新会话、更改工作目录等），最终成为一个守护进程，在后台持续运行。
并行任务处理：父进程可以创建多个子进程来并行处理任务，当父进程完成自己的任务后退出，子进程可以继续独立地完成剩余的任务，提高系统的处理效率。

孤儿进程是嵌入式 Linux 系统中一种正常的进程状态，了解其产生原因、特点和处理方式，有助于开发者更好地进行进程管理和系统开发。

四、常见问题

4.1. 守护进程的常见问题

问题1：资源泄漏

现象：守护进程长时间运行后内存或文件描述符泄漏，导致系统资源耗尽。
原因：
- 未正确关闭文件描述符、套接字或动态分配的内存。
- 第三方库未释放资源。
解决：
- 使用工具（如valgrind、strace）检测泄漏。
- 确保所有malloc/open操作都有配对的free/close。
- 通过ulimit限制资源使用。

问题2：日志管理不当

现象：日志文件占满存储空间，系统崩溃。
原因：未限制日志大小或未使用循环日志。
解决：
- 使用syslog服务（如rsyslog）集中管理日志。
- 限制日志文件大小（如logrotate工具）。
- 在资源紧张时关闭调试日志。

问题3：信号处理缺失

现象：守护进程无法响应SIGTERM或SIGHUP，导致无法优雅退出或重载配置。
解决：注册信号处理函数，使用sigaction替代signal：

void handle_signal(int sig) {
    if (sig == SIGTERM) exit(EXIT_SUCCESS);
}
struct sigaction sa;
sa.sa_handler = handle_signal;
sigemptyset(&sa.sa_mask);
sigaction(SIGTERM, &sa, NULL);

问题4：依赖终端环境

现象：守护进程意外终止或行为异常。
原因：未完全脱离终端（如未正确调用setsid）。
解决：
- 严格遵循守护进程创建步骤（两次fork）。
- 通过ps -ef检查进程是否属于独立会话（SID与PID不同）。

4.2. 僵尸进程的常见问题

问题1：僵尸进程堆积

现象：系统PID耗尽，无法创建新进程。
原因：父进程未调用wait/waitpid回收子进程。

解决：

方案1：父进程注册SIGCHLD信号处理函数：

void sigchld_handler(int sig) {
    while (waitpid(-1, NULL, WNOHANG) > 0); // 非阻塞回收所有子进程
}
signal(SIGCHLD, sigchld_handler);

方案2：显式忽略SIGCHLD（部分系统支持）：

signal(SIGCHLD, SIG_IGN); // 内核自动回收子进程

问题2：信号竞争（Race Condition）

现象：僵尸进程未被及时回收。
原因：多个子进程同时退出，信号处理函数漏掉部分SIGCHLD。
解决：在信号处理函数中使用while + WNOHANG循环，确保回收所有终止的子进程。

问题3：调试困难

现象：难以定位僵尸进程的父进程。
解决：
- 通过ps aux | grep Z查找僵尸进程及其父进程PPID。
- 终止父进程（kill -9 PPID）或强制回收僵尸进程。

4.3. 孤儿进程的常见问题

问题1：资源未释放

现象：孤儿进程占用文件、套接字或共享内存。
原因：父进程终止前未清理子进程资源。
解决：
- 父进程应在终止前主动终止子进程。
- 子进程自身需通过atexit或信号处理释放资源。

问题2：预期外的行为

现象：孤儿进程逻辑依赖父进程状态（如共享内存）。
原因：父进程终止后，子进程仍尝试访问无效资源。
解决：
- 子进程应检测父进程状态（如通过getppid()检查是否变为init）。
- 使用进程间通信（IPC）机制（如管道、信号量）同步状态。

五、参考资料

《Unix 环境高级编程（第 3 版）》（Advanced Programming in the Unix Environment, 3rd Edition）
- 作者：W. Richard Stevens、Stephen A. Rago
- 简介：这本书是 Unix 和类 Unix 系统编程领域的经典之作。
《Linux 系统编程》（Linux System Programming）
- 作者：Robert Love
- 简介：专注于 Linux 系统下的编程技术，详细介绍了守护进程、僵尸进程和孤儿进程的底层原理和实现细节。
《深入理解计算机系统（第 3 版）》（Computer Systems: A Programmer's Perspective, 3rd Edition）
- 作者：Randal E. Bryant、David R. O'Hallaron
- 简介：从计算机系统的底层原理出发，阐述了进程的概念、生命周期以及各种进程状态的产生原因。
Linux 手册页（man pages）
- 获取方式：在 Linux 系统终端中，使用 man 命令查看相关内容，如 man fork、man wait 等；也可访问在线版本 man7.org。
- 简介：这是最权威的 Linux 系统调用参考资料。关于守护进程、僵尸进程和孤儿进程相关的系统调用（如 fork()、wait()、setsid() 等）的手册页，详细说明了函数的原型、参数、返回值以及使用示例，是学习和使用这些系统调用的重要依据。
GNU C Library 文档
- 获取方式：访问 GNU 官方网站。
- 简介：GNU C Library 是 Linux 系统中广泛使用的 C 标准库，其文档对与进程管理相关的库函数进行了详细描述。
Stack Overflow
- 获取方式：访问 Stack Overflow 官网，搜索相关问题。
- 简介：这是一个知名的技术问答社区，有大量关于守护进程、僵尸进程和孤儿进程的讨论和问答。

【嵌入式Linux应用开发基础】特殊进程

一、守护进程（Daemon Process）

1.1. 概念

1.2. 特点

1.3. 守护进程的命名

1.4. 创建守护进程的步骤