编辑“︁C 语言守护进程”︁

{{DISPLAYTITLE:C语言守护进程}}

'''守护进程'''（Daemon Process）是运行在操作系统后台的一种特殊进程，通常用于执行系统级任务或长期运行的服务。在类Unix系统中，守护进程通常不与任何终端关联，并且在系统启动时自动运行。本文将详细介绍如何在C语言中创建和管理守护进程。

== 概述 ==

守护进程是一种在后台运行的程序，它不依赖于用户终端，通常在系统启动时启动，并在系统关闭时终止。守护进程通常用于执行系统服务，例如日志记录、任务调度、网络服务等。

守护进程的主要特点包括：
* 脱离终端控制，独立运行
* 通常在系统启动时启动
* 以root权限运行（部分守护进程）
* 不直接与用户交互

== 守护进程的创建步骤 ==

在C语言中，创建一个守护进程通常需要以下步骤：

1. 调用`fork()`创建子进程，然后退出父进程
2. 调用`setsid()`创建新会话
3. 改变当前工作目录
4. 重设文件权限掩码
5. 关闭不需要的文件描述符
6. 处理信号

下面是一个完整的守护进程创建示例：

<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>

void daemonize() {
    pid_t pid;
    
    // 1. 创建子进程，退出父进程
    pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    }
    if (pid > 0) {
        exit(EXIT_SUCCESS);  // 父进程退出
    }
    
    // 2. 创建新会话
    if (setsid() < 0) {
        perror("setsid");
        exit(EXIT_FAILURE);
    }
    
    // 3. 改变工作目录
    if (chdir("/") < 0) {
        perror("chdir");
        exit(EXIT_FAILURE);
    }
    
    // 4. 重设文件权限掩码
    umask(0);
    
    // 5. 关闭标准输入、输出、错误
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);
}

void signal_handler(int sig) {
    // 处理信号
    switch(sig) {
        case SIGHUP:
            // 重新加载配置
            break;
        case SIGTERM:
            // 清理并退出
            exit(EXIT_SUCCESS);
            break;
    }
}

int main() {
    daemonize();
    
    // 设置信号处理
    signal(SIGHUP, signal_handler);
    signal(SIGTERM, signal_handler);
    
    // 守护进程主循环
    while(1) {
        // 执行守护进程任务
        sleep(60);  // 示例：每分钟执行一次
    }
    
    return EXIT_SUCCESS;
}
</syntaxhighlight>

== 守护进程的生命周期 ==

<mermaid>
graph TD
    A[启动] --> B[fork创建子进程]
    B --> C[父进程退出]
    C --> D[子进程创建新会话]
    D --> E[改变工作目录]
    E --> F[重设文件权限掩码]
    F --> G[关闭文件描述符]
    G --> H[设置信号处理]
    H --> I[主循环执行任务]
    I -->|收到终止信号| J[清理资源]
    J --> K[退出]
</mermaid>

== 实际应用案例 ==

=== 日志守护进程 ===

一个常见的守护进程应用是系统日志服务。以下是一个简单的日志守护进程示例：

<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include <string.h>

#define LOG_FILE "/var/log/mydaemon.log"

void log_message(const char *message) {
    FILE *logfile = fopen(LOG_FILE, "a");
    if (logfile == NULL) {
        return;
    }
    
    time_t now;
    time(&now);
    char *timestamp = ctime(&now);
    timestamp[strlen(timestamp)-1] = '\0';  // 移除换行符
    
    fprintf(logfile, "[%s] %s\n", timestamp, message);
    fclose(logfile);
}

int main() {
    pid_t pid = fork();
    if (pid < 0) exit(EXIT_FAILURE);
    if (pid > 0) exit(EXIT_SUCCESS);  // 父进程退出
    
    setsid();
    chdir("/");
    umask(0);
    
    // 关闭标准文件描述符
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);
    
    // 主循环
    while(1) {
        log_message("Daemon is running");
        sleep(60);  // 每分钟记录一次
    }
    
    return EXIT_SUCCESS;
}
</syntaxhighlight>

=== 网络服务守护进程 ===

另一个常见应用是网络服务守护进程，如Web服务器：

<syntaxhighlight lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT 8080

void handle_client(int client_socket) {
    char response[] = "HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello World!";
    write(client_socket, response, sizeof(response)-1);
    close(client_socket);
}

int main() {
    // 守护进程化
    pid_t pid = fork();
    if (pid < 0) exit(EXIT_FAILURE);
    if (pid > 0) exit(EXIT_SUCCESS);
    
    setsid();
    chdir("/");
    umask(0);
    
    // 创建套接字
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        exit(EXIT_FAILURE);
    }
    
    struct sockaddr_in address = {
        .sin_family = AF_INET,
        .sin_addr.s_addr = INADDR_ANY,
        .sin_port = htons(PORT)
    };
    
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        exit(EXIT_FAILURE);
    }
    
    if (listen(server_fd, 10) < 0) {
        exit(EXIT_FAILURE);
    }
    
    // 主循环
    while(1) {
        int client_socket = accept(server_fd, NULL, NULL);
        if (client_socket < 0) continue;
        
        handle_client(client_socket);
    }
    
    return EXIT_SUCCESS;
}
</syntaxhighlight>

== 守护进程管理 ==

在Linux系统中，可以使用以下命令管理守护进程：

* 查看守护进程：`ps -ef | grep daemon`
* 终止守护进程：`kill <PID>`
* 发送信号给守护进程：`kill -<signal> <PID>`

== 最佳实践 ==

1. '''日志记录'''：守护进程应该将重要事件记录到日志文件中
2. '''配置文件'''：使用配置文件而不是硬编码参数
3. '''信号处理'''：正确处理信号以实现优雅关闭
4. '''资源限制'''：监控资源使用情况，防止内存泄漏
5. '''权限管理'''：以最小必要权限运行

== 常见问题 ==

=== 如何防止守护进程多次启动？ ===

可以使用文件锁来确保只有一个实例运行：

<syntaxhighlight lang="c">
#include <fcntl.h>
#include <unistd.h>

int check_single_instance(const char *lockfile) {
    int fd = open(lockfile, O_RDWR | O_CREAT, 0640);
    if (fd < 0) {
        return -1;
    }
    
    if (lockf(fd, F_TLOCK, 0) {
        close(fd);
        return -1;  // 已经有一个实例在运行
    }
    
    return fd;  // 返回文件描述符，不要关闭
}
</syntaxhighlight>

=== 如何让守护进程重新加载配置？ ===

可以通过处理SIGHUP信号实现：

<syntaxhighlight lang="c">
void reload_config(int sig) {
    // 重新加载配置
    // ...
}

int main() {
    // ...
    signal(SIGHUP, reload_config);
    // ...
}
</syntaxhighlight>

== 数学表示 ==

守护进程可以形式化表示为：

<math>
D = \{P | P \in \text{Processes}, \text{detached}(P), \text{persistent}(P)\}
</math>

其中：
* <math>\text{detached}(P)</math>表示进程P与终端分离
* <math>\text{persistent}(P)</math>表示进程P长期运行

== 总结 ==

守护进程是Unix/Linux系统中重要的后台服务实现方式。通过本文的介绍，你应该已经了解了：
* 守护进程的基本概念和特点
* 创建守护进程的标准步骤
* 实际应用案例
* 管理守护进程的最佳实践
* 常见问题的解决方案

掌握守护进程的编程技术对于开发系统级服务和后台应用至关重要。

[[Category:编程语言]]
[[Category:C]]
[[Category:C 语言系统编程]]