【linux】信号的理论概述和实操

参数

• how：指定如何更改信号屏蔽。这个参数可以是以下三个常量之一：

  • SIG_BLOCK：新的信号屏蔽是当前屏蔽与set指向的集合的并集。即，set中指定的信号将被添加到当前进程的屏蔽中。
  • SIG_UNBLOCK：新的信号屏蔽是当前屏蔽与set指向的集合的差集。即，set中指定的信号将从当前进程的屏蔽中移除。
  • SIG_SETMASK：新的信号屏蔽直接设置为set指向的集合。即，忽略当前进程的屏蔽，并使用set中指定的新屏蔽。

• set：指向sigset_t类型的指针，表示要更改的信号集。如果how是SIG_SETMASK，则这个集合将直接成为新的信号屏蔽。如果how是SIG_BLOCK或SIG_UNBLOCK，则这个集合中的信号将被相应地添加到或从当前屏蔽中移除。

• oset：如果此参数非空，则指向的sigset_t变量将被设置为函数调用前的信号屏蔽。这允许调用者保存旧的屏蔽并在以后恢复它。

返回值

成功时，sigprocmask返回0。失败时，返回-1，并设置errno以指示错误。

#include <stdio.h>  
#include <signal.h>  
#include <string.h>  
#include <unistd.h>  
  
void handler(int sig) {  
    printf("Caught signal %d\n", sig);  
}  
  
int main() {  
    sigset_t set, oldset;  
  
    // 设置SIGINT的处理程序  
    signal(SIGINT, handler);  
  
    // 初始化信号集  
    sigemptyset(&set);  
    sigaddset(&set, SIGINT);  
  
    // 阻塞SIGINT  
    if (sigprocmask(SIG_BLOCK, &set, &oldset) == -1) {  
        perror("sigprocmask");  
        return 1;  
    }  
  
    // 现在SIGINT被阻塞了，发送SIGINT信号不会调用handler  
    printf("SIGINT is blocked. Trying to send SIGINT...\n");  
    raise(SIGINT); // 尝试发送SIGINT信号，但不会被处理  
  
    // 恢复旧的信号屏蔽  
    if (sigprocmask(SIG_SETMASK, &oldset, NULL) == -1) {  
        perror("sigprocmask");  
        return 1;  
    }  
  
    // 现在SIGINT不再被阻塞，发送SIGINT信号将调用handler  
    printf("SIGINT is unblocked. Trying to send SIGINT...\n");  
    raise(SIGINT); // 发送SIGINT信号，将调用handler  
  
    return 0;  
}

sigpending

sigpending 函数是 POSIX 系统中用于查询当前进程阻塞（pending）的信号集合的接口。这些信号已经发送给进程，但由于某些原因（如信号被阻塞）而尚未被处理。通过调用 sigpending 函数，程序可以获取这些待处理的信号，并据此做出相应的处理。

#include <signal.h>

int sigpending(sigset_t *set);

参数

• set：指向 sigset_t 类型的指针，用于存储查询到的待处理信号集合。

返回值

• 成功时，sigpending 返回 0。
• 失败时，返回 -1，并设置 errno 以指示错误原因。

#include <stdio.h>  
#include <signal.h>  
#include <string.h>  
  
void print_sigset(const sigset_t *set) {  
    printf("Pending signals: ");  
    for (int i = 1; i < _NSIG; ++i) {  
        if (sigismember(set, i)) {  
            printf("%d ", i);  
        }  
    }  
    printf("\n");  
}  
  
int main() {  
    sigset_t pending;  
  
    // 查询待处理信号集合  
    if (sigpending(&pending) == -1) {  
        perror("sigpending");  
        return 1;  
    }  
  
    // 打印待处理信号集合  
    print_sigset(&pending);  
  
    return 0;  
}

sigaction

sigaction 函数是 POSIX 系统中用于检查和更改与指定信号相关联的处理动作的函数。这个函数比早期用于相同目的的 signal 函数提供了更多的功能和灵活性。通过 sigaction，程序可以精确地指定信号的处理函数、设置信号处理的选项，并查询信号处理的当前状态。

#include <signal.h>

int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);

参数

• signo：指定要操作的信号的编号。
• act：指向 struct sigaction 的指针，包含了新的信号处理动作。如果此参数为 NULL，则不会更改信号的处理动作，但可以用来查询当前的处理动作（如果 oact 非空）。
• oact：如果非空，指向一个 struct sigaction 变量，该变量用于存储调用 sigaction 之前信号的处理动作。这允许程序在更改信号处理动作之前保存它，以便将来恢复。

返回值

• 成功时，sigaction 返回 0。
• 失败时，返回 -1，并设置 errno 以指示错误原因。

struct sigaction 结构

struct sigaction 结构体通常包含以下字段（但具体实现可能有所不同）：

• sa_handler：指向信号处理函数的指针。如果此字段非 NULL，则它是一个普通的信号处理函数。如果为 SIG_IGN，则忽略该信号。如果为 SIG_DFL，则使用信号的默认处理动作。
• sa_sigaction：一个指向函数的指针，该函数用于处理信号，并提供了对信号发生时的额外信息的访问（如 siginfo_t 结构）。这通常与 SA_SIGINFO 标志一起使用。
• sa_mask：一个信号集，指定了在执行信号处理函数期间应该被阻塞的信号。这允许信号处理函数在执行时不受其他信号的干扰。
• sa_flags：一个标志位集合，用于修改信号处理的行为。常见的标志包括 SA_RESTART（如果信号中断了一个系统调用，则自动重启它），SA_NODEFER（在执行信号处理函数时不自动阻塞该信号），和 SA_SIGINFO（使用 sa_sigaction 而不是 sa_handler）。
• sa_restorer：这个字段在现代系统中很少使用，通常被忽略。它最初用于指定一个函数，该函数将恢复被信号处理函数中断的系统调用的执行环境。

#include <stdio.h>  
#include <signal.h>  
#include <stdlib.h>  
#include <string.h>  
#include <unistd.h>  
  
void signal_handler(int signum) {  
    printf("Caught signal %d\n", signum);  
    // 清理资源、关闭文件等操作...  
    exit(signum);  
}  
  
int main() {  
    struct sigaction act;  
  
    // 初始化信号处理结构体  
    memset(&act, 0, sizeof(act));  
    act.sa_handler = signal_handler;  
  
    // 忽略 SIGPIPE 信号（可选）  
    signal(SIGPIPE, SIG_IGN);  
  
    // 设置 SIGINT 信号的处理函数  
    if (sigaction(SIGINT, &act, NULL) == -1) {  
        perror("sigaction");  
        exit(EXIT_FAILURE);  
    }  
  
    // 主循环，等待信号  
    while (1) {  
        pause(); // 暂停执行，等待信号  
    }  
  
    return 0; // 实际上永远不会执行到这里  
}

闹钟

alarm 函数是 UNIX 和类 UNIX 系统（包括 Linux）中用于设置定时器的一个函数，它定义在 <unistd.h> 头文件中。当你调用 alarm 函数并传递给它一个参数 seconds 时，该函数会设置一个定时器，该定时器在指定的秒数后到期。当定时器到期时，如果进程没有捕获 SIGALRM 信号（通过调用 signal 或 sigaction 函数设置信号处理函数），则进程会收到 SIGALRM 信号。如果进程捕获了该信号，那么可以执行一些特定的操作，比如清理资源、记录日志等。

#include <unistd.h>

unsigned int alarm(unsigned int seconds);

参数

• seconds：定时器到期前的秒数。如果 seconds 是 0，则任何当前设置的定时器都会被取消，但不会发送 SIGALRM 信号。

返回值

• 如果之前已经调用了 alarm 并且设置了定时器，alarm 函数会返回之前设置的剩余时间（秒），直到那个定时器到期。如果之前没有设置定时器，则返回 0。

注意事项

1. 定时器重置：如果在一个已经设置了定时器的进程中再次调用 alarm，那么之前的定时器会被新的定时器替换。返回值是之前定时器的剩余时间（如果有的话）。

2. 精度和限制：alarm 函数的精度和限制取决于系统的实现。在一些系统上，alarm 的精度可能较低，因为它基于系统的定时器中断。此外，一些系统可能对 alarm 可以设置的最大时间有限制。

3. 与 sleep/pause 的交互：如果进程在调用 alarm 后调用了 sleep 或 pause，并且 alarm 定时器在 sleep 或 pause 期间到期，那么 sleep 或 pause 会被中断，并且进程会收到 SIGALRM 信号（如果未捕获）。

4. 信号处理：为了处理 SIGALRM 信号，你需要使用 signal 或 sigaction 函数来设置信号处理函数。

#include <stdio.h>  
#include <unistd.h>  
#include <signal.h>  
  
void sigalrm_handler(int sig_num) {  
    printf("Alarm signal received\n");  
    // 在这里执行清理或其他操作  
}  
  
int main() {  
    // 设置 SIGALRM 信号的处理函数  
    signal(SIGALRM, sigalrm_handler);  
  
    // 设置 5 秒后的定时器  
    alarm(5);  
  
    // 暂停执行，等待定时器到期或信号  
    pause();  
  
    return 0;  
}

signal 

在C语言中，signal 函数的原型可能因系统而异，但通常它遵循 POSIX 标准或类似的标准。不过，标准的 C 库（如 glibc）通常会在 <signal.h> 头文件中提供一个符合大多数系统需求的 signal 函数声明。

#include <signal.h>

void (*signal(int sig, void (*func)(int)))(int);

• 参数：
  • int sig：要处理的信号编号。
  • void (*func)(int)：指向信号处理函数的指针，该函数接受一个整型参数（信号编号）并返回 void。
• 返回值：
  • 返回一个指向之前为该信号设置的信号处理函数的指针（也接受一个整型参数并返回 void），或者返回 SIG_ERR 以表示错误，并设置 errno 以指示错误原因。

#include <stdio.h>  
#include <stdlib.h>  
#include <signal.h>  
#include <unistd.h>  
  
// 信号处理函数  
void handler(int sig_num) {  
    printf("Caught signal %d\n", sig_num);  
    // 可以在这里执行清理操作或退出程序  
    exit(0); // 或者使用其他逻辑来响应信号  
}  
  
int main() {  
    // 设置 SIGINT 信号的处理函数  
    if (signal(SIGINT, handler) == SIG_ERR) {  
        // 如果 signal 调用失败，则打印错误信息并退出  
        perror("signal");  
        exit(EXIT_FAILURE);  
    }  
  
    // 程序的主循环或其他逻辑  
    while (1) {  
        printf("Waiting for signal...\n");  
        sleep(1); // 暂停一秒，以便可以看到信号何时被捕获  
    }  
  
    // 注意：实际上，由于我们在信号处理函数中调用了 exit，  
    // 所以这行代码永远不会被执行。  
    return 0;  
}

【linux】进程控制——进程创建，进程退出，进程等待-CSDN博客

【linux】进程间通信(IPC)——匿名管道，命名管道与System V内核方案的共享内存，以及消息队列和信号量的原理概述-CSDN博客