阻塞信号

信号相关概念

• 实际执行信号的处理动作称为信号递达(Delivery)
• 信号从产生到递达之间的状态，称为信号未决(Pending)。
  已经收到但未处理的状态
• 进程可以选择阻塞 (Block )某个信号
• 被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作
• 注意，阻塞和忽略是不同的，只要信号被阻塞就不会递达，而忽略是在递达之后可选的一种处理动作

内核中的表示

• 每个信号都有两个标志位分别表示 阻塞(block) 和 未决(pending) ，还有一个函数指针表示处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志。
• 在上图的例子中，SIGHUP信号未阻塞也未产生过，当它递达时执行默认处理动作。
• SIGINT信号产生过，但正在被阻塞，所以暂时不能递达。虽然它的处理动作是忽略，但在没有解除阻塞之前不能忽略这个信号，因为进程仍有机会改变处理动作之后再解除阻塞。
• SIGQUIT信号未产生过，一旦产生SIGQUIT信号将被阻塞，它的处理动作是用户自定义函数sighandler()。 如果在进程解除对某信号的阻塞之前这种信号产生过多次，将如何处理?POSIX.1允许系统递送该信号一次或多次。Linux是这样实现的:常规信号在递达之前产生多次只计一次，而实时信号在递达之前产生多次可以依次放在一个队列里，本文不讨论实时信号。

处理方法举例：

if( (1<<(signo - 1))& pcb->block )
{
    // signo信号是被阻塞的，不抵达
}
else
{
    if((1<<(signo - 1)) &pcb-> pending)
    {
        // 递达该信号
    }
}

• 数组的位置(下标)，信号的编号
• 数组下标对应的内容，表示对应信号的处理方法

如果一个信号没有产生，并不妨碍它可以先被阻塞

sigset_t

由上图得知：每个信号只有一个bit的未决标志，非0即1，不记录该信号产生了多少次，阻塞标志也是这样表示的。

因此，未决和阻塞标志可以用相同的数据类型sigset_t来存储，sigset_t称为信号集，这个类型可以表示每个信号的“有效”或“无效”状态，在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞，而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。下面将详细介绍信号集的各种操作。

阻塞信号集也叫做当前进程的信号屏蔽字(Signal Mask)，这里的“屏蔽”应该理解为阻塞而不是忽略

信号集操作函数

sigset_t类型对于每种信号用一个bit表示“有效”或“无效”状态，至于这个类型内部如何存储这些bit则依赖于系统实现，从使用者的角度是不必关心的，使用者只能调用以下函数来操作sigset_ t变量，而不应该对它的内部数据做任何解释，比如用printf直接打印sigset_t变量是没有意义的

#include <signal.h>
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset (sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
int sigpending(sigset_t *set);
int sigismember(const sigset_t *set, int signo);

• 函数sigemptyset：初始化set所指向的信号集，使其中所有信号的对应bit清零，表示该信号集不包含任何有效信号。
• 函数sigfillset：初始化set所指向的信号集，使其中所有信号的对应bit填满，表示该信号集的有效信号包括系统支持的所有信号。
• 函数sigaddset：向信号集set中添加信号signo。
• 函数sigdelset ：从信号集set中删除信号signo。
• 函数sigprocmask：是一个系统调用，用于控制进程的信号掩码
• 函数sigpending：用于获取当前被阻塞（pending）的信号集合
• 函数sigismember ：判断信号signo是否属于信号集set，如果是则返回非零值，否则返回零。
• 注意：在使用sigset_ t类型的变量之前，一定要调用sigemptyset或sigfillset做初始化，使信号集处于确定的状态。初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号。

前六个函数都是成功返回0，出错返回-1。sigismember是一个布尔函数，用于判断一个信号集的有效信号中是否包含某种信号，若包含则返回1，不包含则返回0，出错返回-1。

sigprocmask

函数功能：
sigprocmask函数用于获取或更改当前进程的信号掩码。信号掩码是一个位向量，用于控制进程是否接收某些信号的通知。使用sigprocmask函数，可以阻塞、解除阻塞或替换当前进程的信号掩码。

函数原型：

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

函数参数：

• how：一个整数，指定如何修改进程的信号掩码。可以是以下三个值之一：
  1.SIG_BLOCK：将set中指定的信号添加到进程的信号掩码中。
  2.SIG_UNBLOCK：将set中指定的信号从进程的信号掩码中删除。
  3.SIG_SETMASK：用set中指定的信号替换进程的信号掩码。
• set：一个指向sigset_t类型的指针，指定要添加、删除或替换的信号集合。如果how的值是SIG_UNBLOCK，则忽略此参数。
• oldset：一个指向sigset_t类型的指针，用于存储调用前的信号掩码。如果不需要此信息，则可以将其设置为NULL。

函数返回值：
如果成功，返回0。如果失败，返回-1，并设置errno以反映错误的原因。

sigpending

函数原型：

int sigpending(sigset_t *set);

函数功能：
sigpending函数用于获取当前被阻塞(pending)的信号集合。挂起的信号是一些当前已经发送给进程但是还没有被处理的信号。

函数参数：

• set：一个指向sigset_t类型的指针，用于存储被阻塞的信号集合。

函数返回值：
如果成功，返回0，如果失败，返回-1，并设置errno以反映错误的原因。

小实验 - 观察pending表

实验：发送一个信号，如果被屏蔽那么这个信号就不会被递达，然后存放入pending表

#include <iostream>
#include <vector>
#include <signal.h>
#include <unistd.h>

// #define BLOCK_SIGNAL 2
#define MAX_SIGNUM 31

using namespace std;

// static vector<int> sigarr = {2,3};
static vector<int> sigarr = {2};

static void show_pending(const sigset_t &pending)
{
    for(int signo = MAX_SIGNUM; signo >= 1; signo--)
    {
        if(sigismember(&pending, signo))
        {
            cout << "1";
        }
        else cout << "0";
    }
    cout << "\n";
}

static void myhandler(int signo)
{
    cout << signo << " 号信号已经被递达!!" << endl;
}

int main()
{
    for(const auto &sig : sigarr) signal(sig, myhandler);

    // 1. 先尝试屏蔽指定的信号
    sigset_t block, oblock, pending;
    // 1.1 初始化
    sigemptyset(&block);
    sigemptyset(&oblock);
    sigemptyset(&pending);
    // 1.2 添加要屏蔽的信号
    for(const auto &sig : sigarr) sigaddset(&block, sig);
    // 1.3 开始屏蔽,设置进内核(进程)
    sigprocmask(SIG_SETMASK, &block, &oblock);

    // 2. 遍历打印pengding信号集
    int cnt = 10;
    while(true)
    {
        // 2.1 初始化
        sigemptyset(&pending);
        // 2.2 获取它
        sigpending(&pending);
        // 2.3 打印它
        show_pending(pending);
        // 3. 慢一点
        sleep(1);
        if(cnt-- == 0)
        {
            sigprocmask(SIG_SETMASK, &oblock, &block); // 一旦对特定信号进行解除屏蔽，一般OS要至少立马递达一个信号！
            cout << "恢复对信号的屏蔽，不屏蔽任何信号\n";
        }
    }
}

---

用户态：1.操作系统自身的资源（getpid、waitpid）2.硬件资源（printf、write）
用户为了访问内核或者硬件的资源必须通过系统调用完成访问，往往系统调用比较费时间，所以要尽量避免频繁调用系统调用。实际执行系统调用的进程“用户”，但是身份其实是内核。

我是一个进程，怎么跑到OS中执行方法呢？

进程通过系统调用接口，系统调用接口会自己将进程的运行级别更改为内核态，这样就有权限去访问内核里面的调用，返回的时候又会由内核态转换为用户态。

---

信号的捕捉流程

信号产生的时候，不会被立即处理，而是在合适的时候→从内核态返回用户态的时候，那么这样我们一顶是曾经先进入了内核态（系统调用、进程切换）

陷入内核执行自定义信号捕捉方法流程：

信号捕捉：

我们能不能以内核态的身份去执行用户态代码？
答案是不能，操作系统无法识别里面的内容是合法还是非法，如果以内核态的身份去执行用户态的代码，很容易这份代码被恶意分子利用，以一个内核态的身份在一定程度的越权去执行非法动作。即便我们技术上可能实现，但是我们也不能这样。

sigaction

//函数原型
int sigaction(int signum, const struct sigaction *act,
                     struct sigaction *oldact);

struct sigaction {
	void     (*sa_handler)(int);
	void     (*sa_sigaction)(int, siginfo_t *, void *);
	sigset_t   sa_mask;
	int        sa_flags;
	void     (*sa_restorer)(void);
};

用法：

#include <iostream>
#include <signal.h>
#include <unistd.h>
using namespace std;
void handler(int signo)
{
    cout << "get a signo: " << signo << "正在处理中..." << endl;
}
int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask); 
    sigaction(SIGINT, &act, &oact);
    while(true) sleep(1);
    return 0;
}

1.小实验：如果进程在处理2号信号，那我们继续发送2号信号会怎么样？

我们对上面的代码做修改：

void Count(int cnt)
{
    while(cnt)
    {
        printf("cnt: %2d\r", cnt);
        fflush(stdout);
        cnt--;
        sleep(1);
    }
    printf("\n");
}
void handler(int signo)
{
    cout << "get a signo: " << signo << "正在处理中..." << endl;
    Count(20);
}
int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask); 
    sigaction(SIGINT, &act, &oact);
    while(true) sleep(1);
    return 0;
}

输出结果：
我们一次性发了6个kill -2 (pid)但是从一开始到最后，我们最终只运行了两个。

结论：
当我们进行正在递达某一个信号期间，同类型信号无法被递达！当当前信号正在被捕捉系统会自动将当前信号加入到进程的信号屏蔽字block。当信号完成捕捉动作，系统又会自动解除对该信号的屏蔽。

为什么运行了两次？我们在运行时，第一个命令发送2号信号被捕捉，信号在递达前会将pending表置为0，接下来发送相同命令kill -2 (pid)可以，但是都更改的是同一个pending表(将相同表的同一位置反复置1)，这也会再运行一次，原因：一般一个信号被解除屏蔽的时候，会自动进行递达当前屏蔽信号，如果该信号已经被pending的话，没有就不做任何动作！

我们进程处理信号的原则是串行的处理同类型的信号，不允许递归

2.如何正在处理这个信号，同时屏蔽其他信号

当我们正在处理某一种信号的时候，我们也想顺便屏蔽其他信号，就可以添加到这个sa_mask中

sigaddset(&act.sa_mask, 3);//3号快捷键是ctrl + \

运行结果：

当2号信号处理完以后，2号信号与3号信号的屏蔽都会一起解除。当然因为发送了3号信号，它的pending表已经置1，在处理完2号信号后就会执行3号信号。

3.观察pending表验证上述

我们将pending表同时打印出来印证上面情况：
将打印pending内容添加在计数函数Count中：

static void show_pending(const sigset_t &pending)
{
    for(int signo = MAX_SIGNUM; signo >= 1; signo--)
    {
        if(sigismember(&pending, signo))
        {
            cout << "1";
        }
        else cout << "0";
    }
    cout << "\n";
}
void Count(int cnt)
{
    while(cnt)
    {
        printf("cnt: %2d\r", cnt);
        fflush(stdout);
        cnt--;
        sleep(1);
        
        sigset_t pending;
        // 2.1 初始化
        sigemptyset(&pending);
        // 2.2 获取它
        sigpending(&pending);
        // 2.3 打印它
        show_pending(pending);
        // 3. 慢一点
        sleep(1);
    }
    printf("\n");
}

输出现象：


我们在捕捉到第一个2号信号并开始执行的时候，此时这个pending表2号位已经置0，我们再次传入kill -2 (pid)，这个时候pending表2号位置为1，由于我们在本章第二小点，我们在处理这个信号时，将3号信号屏蔽了，所以我们继续传入kill -3 (pid)并不会终止，而是样将pending表3号位置1。最终运行结果是：等第一个2号信号结束，会继续运行下一个2号信号，等待这个2号信号也结束，才会执行3号信号。

---

可重入函数

main函数调用insert函数向一个链表head中插入节点node1，插入操作分为两步，刚做完第一步的时候，因为硬件中断使进程切换到内核，再次回用户态之前检查到有信号待处理，于是切换到sighandler函数，sighandler也调用insert函数向同一个链表head中插入节点node2，插入操作的两步都做完之后从sighandler返回内核态，再次回到用户态就从main函数调用的insert函数中继续往下执行，先前做第一步之后被打断，现在继续做完第二步。结果是，main函数和sighandler先后向链表中插入两个节点，而最后只有一个节点真正插入链表中了。

像上例这样，insert函数被不同的控制流程调用，有可能在第一次调用还没返回时就再次进入该函数，这称为重入，insert函数访问一个全局链表，有可能因为重入而造成错乱，像这样的函数称为不可重入函数，反之，如果一个函数只访问自己的局部变量或参数，则称为可重入(Reentrant)函数。想一下，为什么两个不同的控制流程调用同一个函数，访问它的同一个局部变量或参数就不会造成错乱?

1. 一般而言，我们认为: main执行流，和信号捕捉执行流是两个执行流!
2. 如果在main中，和在handler中，该函数被重复进入，出问题–该函数insert不可重入函数
3. 如果在main中，和在handler中，该函数被重复进入，没有出问题-该函数insert可重入函数

不可重入是问题么?因为如果这是一个问题话，我们需要想办法解决问题，我们目前大部分情况下用的接口，全部都是不可重入的！不可重入不是问题是特性，是一个中性词！

如果一个函数符合以下条件之一则是不可重入的:

• 调用了malloc或free，因为malloc也是用全局链表来管理堆的。
• 调用了标准I/O库函数。标准I/O库的很多实现都以不可重入的方式使用全局数据结构。

---

volatile

volatile:保持内存可见性

我们下执行下面代码：

int quit = 0;
void handler(int signo)
{
    printf("pid: %d, %d 号信号，正在被捕捉!\n", getpid(), signo);
    printf("quit: %d", quit);
    quit = 1;
    printf("-> %d\n", quit);
}
int main()
{
    signal(2, handler);
    while (!quit);
    printf("注意，我是正常退出的! \n");
    return 0;
}

执行结果：

我们更改一下编译器的优化等级：

gcc -o mysignal  mysignal.c -O3

解释图：
一开始：

更改编译器优化等级

为了让内存保持可见性：

volatile int quit = 0;

这样quit加上volatile就可以让cpu在执行的时候，与内存时刻保持联系

---

SIGCHLD信号 - 相关僵尸进程

之前讲过用wait和waitpid函数清理僵尸进程，父进程可以阻塞等待子进程结束，也可以非阻塞地查询是否有子进程结束等待清理(也就是轮询的方式)。采用第一种方式，父进程阻塞了就不能处理自己的工作了；采用第二种方式，父进程在处理自己的工作的同时还要记得时不时地轮询一下，程序实现复杂。

其实，子进程在终止时会给父进程发SIGCHLD信号，该信号的默认处理动作是忽略，父进程可以自定义SIGCHLD信号的处理函数，这样父进程只需专心处理自己的工作，不必关心子进程了，子进程终止时会通知父进程，父进程在信号处理函数中调用wait清理子进程即可。

1.验证子进程退出发送退出信号SIGCHLD给父进程

volatile int quit = 0;
void handler(int signo)
{
    printf("pid: %d, %d 号信号，正在被捕捉!\n", getpid(), signo);
    printf("quit: %d", quit);
    quit = 1;
    printf("-> %d\n", quit);
}
void Count(int cnt)
{
    while (cnt)
    {
        printf("cnt: %2d\r", cnt);
        fflush(stdout);
        cnt--;
        sleep(1);
    }
    printf("\n");
}
int main()
{
    signal(SIGCHLD, handler);
    printf("我是父进程, %d, ppid: %d\n", getpid(), getppid());

    pid_t id = fork();
    if (id == 0)
    {
        printf("我是子进程, %d, ppid: %d,我要退出啦\n", getpid(), getppid());
        Count(5);
        exit(1);
    }
    return 0;
}

我们可以发现，在子进程退出以后，父进程确实收到了退出信号SIGCHLD。

这个SIGCHLD默认是：

2.编写一个程序完成以下功能：父进程fork出子进程，子进程调用exit(2)终止，父进程自定义SIGCHLD信号的处理函数，在其中调用wait获得子进程的退出状态并打印。

void handler(int sig)
{
    pid_t id;
    while ((id = waitpid(-1, NULL, WNOHANG)) > 0)
    {
        printf("wait child success: %d\n", id);
    }
    printf("child is quit! %d\n", getpid());
}
int main()
{
    signal(SIGCHLD, handler);
    pid_t cid;
    if ((cid = fork()) == 0)
    { // 子进程
        printf("child : %d\n", getpid());
        sleep(3);
        exit(2);
    }
    while (1)
    {
        printf("father proc is doing some thing! pid:%d\n",getpid());
        sleep(1);
    }
    return 0;
}

上面自定义handler的处理方法，回收子进程资源这样写是因为，可能不止一个子进程资源需要回收。如果直接waitpid回收，其他子进程退出后发送相同的退出信号SIGCHLD那么跟之前一样只会处理两次信号，其余的会忽略，这样不是所有的子进程资源都会被回收。

3.验证调用sigaction将SIGCHLD的处理动作置为SIG_IGN不会产生僵尸进程

事实上，由于UNIX的历史原因，要想不产生僵尸进程还有另外一种办法:父进程调用sigaction将SIGCHLD的处理动作置为SIG_IGN，这样fork出来的子进程在终止时会自动清理掉，不会产生僵尸进程，也不会通知父进程。系统默认的忽略动作和用户用sigaction函数自定义的忽略通常是没有区别的，但这是一个特例。此方法对于Linux可用，但不保证在其它UNIX系统上都可用。

验证上述做不会产生僵尸进程：

void Count(int cnt)
{
    while (cnt)
    {
        printf("cnt: %2d\r", cnt);
        fflush(stdout);
        cnt--;
        sleep(1);
    }
    printf("\n");
}
int main()
{
    // 显示的设置对SIGCHLD进行忽略
    signal(SIGCHLD, SIG_IGN);
    printf("我是父进程, %d, ppid: %d\n", getpid(), getppid());
    pid_t id = fork();
    if (id == 0)
    {
        printf("我是子进程, %d, ppid: %d,我要退出啦\n", getpid(), getppid());
        Count(5);
        exit(1);
    }
    while (1)sleep(1);
    return 0;
}

循环打印进程信息脚本：

while :; do ps axj | head -1 && ps axj | grep mysignal | grep -v grep;sleep 1;echo "--------------"; done

在之前，我们子进程退出后会进入僵尸状态，现在子进程退出后直接被回收，我们都没看到关于子进程的信息了。

显示的设置对SIGCHLD进行忽略，与它本身信号默认处理动作是Ign，所表现出来的动作是不一样的。使用默认的就是之前出现僵尸进程的流程，手动的设置会更改原本的处理动作。这两个区分度是不一样的。

---

如有错误或者不清楚的地方欢迎私信或者评论指出🚀🚀