来源：ChatGPT

在 Linux 系统上，进程通过信号的方式重新加载配置是一种常见的做法。通常可以选择以下信号：

SIGHUP (挂起信号)：

传统上用于通知进程重新加载配置文件。当进程接收到此信号时，可以编写相应的信号处理程序，重新读取配置文件。数据携带：标准信号（如 SIGHUP）不携带数据，仅表示一个触发事件。 1. SIGUSR1 和 SIGUSR2 (用户自定义信号)：

这两个信号可以被应用程序自由定义用途，常用于特定功能，比如重新加载配置、日志轮转等。数据携带：同样，标准信号（如 SIGUSR1 和 SIGUSR2）不能携带数据。发送信号并重载配置的基本步骤

1. 系统信号

1.1 发送信号

#include <csignal>
#include <unistd.h>

int main() {
    pid_t pid = /* 目标进程的PID */;
    kill(pid, SIGHUP);  // 发送SIGHUP信号
    return 0;
}

1.2 监听信号

#include <csignal>
#include <iostream>

void handle_sighup(int signum) {
    std::cout << "重新加载配置...\n";
    // 在这里重新加载配置逻辑
}

int main() {
    std::signal(SIGHUP, handle_sighup);  // 设置信号处理函数
    // 主进程逻辑
    while (true) {
        pause();  // 等待信号
    }
    return 0;
}

2. 使用实时信号 (Real-time Signals)

POSIX 实时信号可以携带附加数据，且在队列中保存：

实时信号范围：SIGRTMIN 到 SIGRTMAX。发送实时信号可以携带附加的整数数据：

2.1 发送信号

#include <csignal>
#include <unistd.h>

int main() {
    pid_t pid = /* 目标进程的PID */;
    union sigval value;
    value.sival_int = 42;  // 携带的数据
    sigqueue(pid, SIGRTMIN, value);  // 发送实时信号和数据
    return 0;
}

2.2 监听信号

#include <csignal>
#include <iostream>

void handle_sig(int signum, siginfo_t *info, void *context) {
    std::cout << "收到实时信号 " << signum << "，数据：" << info->si_value.sival_int << "\n";
    // 在这里可以重载配置逻辑
}

int main() {
    struct sigaction action;
    action.sa_sigaction = handle_sig;
    action.sa_flags = SA_SIGINFO;
    sigaction(SIGRTMIN, &action, nullptr);  // 设置信号处理函数

    // 主进程逻辑
    while (true) {
        pause();  // 等待信号
    }
    return 0;
}

3. C++ 中使用 lambda 函数处理信号

#include <csignal>
#include <functional>
#include <iostream>

// 全局 std::function 用于存储 callback
std::function<void(int)> signalHandler;

void signal_callback(int signum) {
    if (signalHandler) {
        signalHandler(signum);  // 调用 lambda 或 std::function
    }
}

int main() {
    // 将 lambda 赋值给 std::function
    signalHandler = [](int signum) {
        std::cout << "收到信号 " << signum << "，处理配置重载\n";
    };

    // 将普通的函数指针设为信号处理函数
    std::signal(SIGUSR1, signal_callback);

    // 模拟主进程逻辑
    while (true) {
        pause();  // 等待信号
    }
    return 0;
}

4. Linux 处理信号会阻塞当前线程的任务

问：在 linux 系统中的信号机制中，当进程接收到一个信号并处理时，是启动了一个新的线程进行处理的吗？

ChatGPT：

在 Linux 系统中，当进程接收到一个信号时，并不会启动一个新的线程来处理信号。相反，信号的处理是在接收信号的线程上下文中进行的，这种处理是同步的，主要有以下几点机制和规则：

1. 信号由某个线程处理

当信号发送给进程时，操作系统会选择一个线程来处理该信号。处理方式如下：

进程范围的信号（例如，通过 kill(pid, signal) 发送的信号）：操作系统会选择进程中任意一个可以处理信号的线程来接收并处理信号。

线程范围的信号（例如，通过 pthread_kill(thread_id, signal) 发送的信号）：信号会发送到指定的线程上，并且只能由该线程来处理。

2. 信号处理是同步的

信号处理函数是在当前线程的上下文中同步执行的，即信号处理会中断当前线程的正常执行流程，进入信号处理函数执行，处理完信号后才会继续执行中断的代码。因此：

信号处理函数并不是在新线程中异步执行的，而是在当前线程被中断的上下文中执行。由于是同步处理，信号处理期间会阻塞当前线程的其他操作，因此信号处理函数应该尽量简短，以免影响线程的正常运行。

3. 多线程与信号的分配

在多线程程序中，信号的分配较为复杂，通常有以下规则：

异步信号安全：信号处理函数只能调用异步信号安全的函数，避免在信号处理过程中引发死锁或资源竞争。屏蔽信号：线程可以通过信号屏蔽字 (sigprocmask) 来控制自己能够接收哪些信号。通过这种方式，可以控制某些信号只由特定线程来处理。

4. 特殊情况：实时信号

POSIX 实时信号在进程范围内排队，且每个信号都会排队，因此进程可以在信号排队时依次处理这些信号。但仍然是在接收信号的线程上下文中处理，而不会创建新的线程。

总结当进程接收到一个信号时，Linux 系统不会启动新的线程来处理，而是在当前接收信号的线程上下文中同步执行信号处理函数。这种机制确保信号处理的快速响应，同时避免了多线程中的复杂性。

进程间通信发送 kill 信号 实时信号