Linux学习（20）：信号集-3

最新推荐文章于 2024-07-12 11:34:40 发布

weixin_43870645

最新推荐文章于 2024-07-12 11:34:40 发布

阅读量69

点赞数

分类专栏： webserver学习第二章文章标签： linux 学习运维

本文链接：https://blog.csdn.net/weixin_43870645/article/details/129766781

版权

webserver学习第二章专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1. sigprocmask函数

- 功能：将自定义信号集中的数据设置到内核中（设置阻塞，解除阻塞，替换）

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
    - 参数：
        - how : 如何对内核阻塞信号集进行处理
            SIG_BLOCK: 将用户设置的阻塞信号集添加到内核中，内核中原来的数据不变
                假设内核中默认的阻塞信号集是mask， mask | set
            SIG_UNBLOCK: 根据用户设置的数据，对内核中的数据进行解除阻塞
                mask &= ~set
            SIG_SETMASK:覆盖内核中原来的值
            
        - set ：已经初始化好的用户自定义的信号集
        - oldset : 保存设置之前的内核中的阻塞信号集的状态，可以是 NULL
    - 返回值：
        成功：0
        失败：-1
            设置错误号：EFAULT（old地址有问题）、EINVAL（how是非法的）

2. sigpending函数

- 功能：获取内核中的未决信号集

int sigpending(sigset_t *set);
    - 参数：set,传出参数，保存的是内核中的未决信号集中的信息。

测试代码

实现把所有的常规信号（1-31）的未决状态打印到屏幕，设置信号阻塞

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

int main() {

    // 设置2、3号信号阻塞
    sigset_t set;
    sigemptyset(&set);
    // 将2号和3号信号添加到信号集中
    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGQUIT);

    // 修改内核中的阻塞信号集为我们定义的set
    sigprocmask(SIG_BLOCK, &set, NULL);

    int num = 0;

    while(1) {
        num++;
        // 获取当前的未决信号集的数据
        sigset_t pendingset;
        sigemptyset(&pendingset);
        sigpending(&pendingset);

        // 遍历前32位
        for(int i = 1; i <= 31; i++) {
            if(sigismember(&pendingset, i) == 1) {
                printf("1");
            }else if(sigismember(&pendingset, i) == 0) {
                printf("0");
            }else {
                perror("sigismember");
                exit(0);
            }
        }

        printf("\n");
        sleep(1);
        if(num == 10) {
            // 解除阻塞
            sigprocmask(SIG_UNBLOCK, &set, NULL);
        }

    }
    return 0;
}

测试分析：我们把SIGINT设置为阻塞并传给了内核，此时在不做任何事时获取到的当前未决信号集是32个0，由于我们阻塞SIGINT，当我们按下ctrl+c时，一个SIGINT信号发给内核在未决信号中，由于他被阻塞无法得到处理，所以进程不会退出，此时获取的未决信号集是01000000000000000000000000000000

SIGINT是1，我们在打印十次后解除了阻塞，不然只能kill -9 /-19去杀死他

sigprocmask(SIG_BLOCK, &set, NULL);
sigprocmask(SIG_UNBLOCK, &set, NULL);

可以看到我们用同样的set去阻塞和解除阻塞，因为BLOCK是‘|’的关系置位，UNBLOCK是&~set的关系，之前置1的位取反后为0再与1与运算从而清零。

3. sigaction函数

- 功能：检查或者改变信号的处理。信号捕捉

#include <signal.h>
int sigaction(int signum, const struct sigaction *act,
                        struct sigaction *oldact);

    - 参数：
        - signum : 需要捕捉的信号的编号或者宏值（信号的名称）
        - act ：捕捉到信号之后的处理动作
        - oldact : 上一次对信号捕捉相关的设置，一般不使用，传递NULL
    - 返回值：
        成功 0
        失败 -1

    struct sigaction {
        void     (*sa_handler)(int);
            函数指针，是一个信号处理函数
        void     (*sa_sigaction)(int, siginfo_t *, void *);//不常用
        sigset_t   sa_mask;
            临时阻塞信号集，在信号捕捉函数执行过程中，临时阻塞某些信号
        int        sa_flags;
            标志位标识符，主要包括 SA_RESTART、SA_NOCLDSTOP 和 SA_SIGINFO 等选项
            最常见是 SA_RESTART ，如果此标志位被设置为真，则内核自动重新启动由于正在进行某些操作而暂停了进程之后未完成任务所导致挂起状态下任何被阻止的系统调用
        void     (*sa_restorer)(void);//老版本，废弃
};

测试代码：使用sigaction完成signal函数的功能

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void myalarm(int num) {
    printf("捕捉到了信号的编号是：%d\n", num);
    printf("xxxxxxx\n");
}

// 过3秒以后，每隔2秒钟定时一次
int main() {

    struct sigaction act;
    act.sa_flags = 0;
    act.sa_handler = myalarm;
    sigemptyset(&act.sa_mask);  // 可能有默认值，清空临时阻塞信号集

    //在捕捉到信号进行myalrm处理时，新进来的信号遵循sa_mask临时阻塞信号集的处理   
    
    // 注册信号捕捉
    sigaction(SIGALRM, &act, NULL);

    struct itimerval new_value;

    // 设置间隔的时间
    new_value.it_interval.tv_sec = 2;
    new_value.it_interval.tv_usec = 0;

    // 设置延迟的时间,3秒之后开始第一次定时
    new_value.it_value.tv_sec = 3;
    new_value.it_value.tv_usec = 0;

    int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的
    printf("定时器开始了...\n");

    if(ret == -1) {
        perror("setitimer");
        exit(0);
    }

    // getchar();对应需要act.sa_flags = SA_RESTART;
    while(1);

    return 0;
}

一些问题

1.注意：我们应尽可能使用sigaction，因为signal是米国人用的非通用标准

2.我们注意到，使用getchar()会终止进程而使用while(1)则不会

sigaction只能捕捉一次SIGALRM的原因在于getchar被中断

getchar()`函数在底层使用了`read()`系统调用来从标准输入流中读取一个字符。

read从终端读取数据是会被signal handler中断

使用getchar()时需要将标志位标识符sa_flags设置为SA_RESTART ，如果此标志位被设置为真，则内核自动重新启动由于正在进行某些操作而暂停了进程之后未完成任务所导致挂起状态下任何被阻止的系统调用，getchar中断后会在当前位置重新启动

4.内核实现信号捕捉的过程

如果是自定义的处理函数，会发生用户态和内核态的切换

5.SIGCHLD信号

SIGCHLD是编号17的信号

产生条件：

1.子进程终止时

2.子进程收到SIGSTOP信号时

3.子进程处于停止态，接收到SIGCONT后被唤醒时

以上三种情况都会给父进程发送SIGCHLD信号，父进程默认忽略

案例：

设计回收程序：

父进程运行且不回收子进程，子进程就会变为僵尸进程，因此子进程结束后发送的信号我们接收后进行处理，用wait函数会一直阻塞，因此使用waitpid函数设置非阻塞

问题又来了，由于未决信号集（1-31）没有排队机制，多个子进程发来信号，只能保存一个位1，所以在接受这一个的时候就应该把所有的僵尸都处理了，用一个while循环

问题又来了，父进程在注册信号捕捉时可能子进程已经结束了，SIGCHLD被忽略了，因此我们应该在注册前先把他阻塞掉，注册后再打开

还有一种解决思路是把注册写在fork之前，但这样一旦写时拷贝，浪费大量空间

void myFun(int num) {
    printf("捕捉到的信号 ：%d\n", num);
    while(1) {
       int ret = waitpid(-1, NULL, WNOHANG);
       if(ret > 0) {
           printf("child die , pid = %d\n", ret);
       } else if(ret == 0) {
           // 说明还有子进程活着
           break;
       } else if(ret == -1) {
           // 没有子进程
           break;
       }
    }
}

int main() {

    // 提前设置好阻塞信号集，阻塞SIGCHLD，因为有可能子进程很快结束，父进程还没有注册完信号捕捉
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGCHLD);
    sigprocmask(SIG_BLOCK, &set, NULL);

    // 创建一些子进程
    pid_t pid;
    for(int i = 0; i < 20; i++) {
        pid = fork();
        if(pid == 0) {
            break;
        }
    }

    if(pid > 0) {
        // 父进程

        // 捕捉子进程死亡时发送的SIGCHLD信号
        struct sigaction act;
        act.sa_flags = 0;
        act.sa_handler = myFun;
        sigemptyset(&act.sa_mask);
        sigaction(SIGCHLD, &act, NULL);

        // 注册完信号捕捉以后，解除阻塞
        sigprocmask(SIG_UNBLOCK, &set, NULL);

        while(1) {
            printf("parent process pid : %d\n", getpid());
            sleep(2);
        }
    } else if( pid == 0) {
        // 子进程
        printf("child process pid : %d\n", getpid());
    }

    return 0;
}

好处：比起单纯waitpid的使用，sigchld信号使得我们可以不必等待子进程回收完毕就继续运行其他的程序，因为子进程的结束的时间可以差异很大