1. 信号概念

信号是进程之间事件异步通知的一种方式，属于软中断。

进程收到信号的时候并不是立即执行，而是将其保存起来，合适的时候再进行响应；这个保存的地方是在struct task_struct，因为信号的本质也是数据，信号的发送过程相当于往task_struct中写入数据。（OS不相信任何人，所以写入过程是由OS自己完成的）

2. 信号产生前

2.1 信号产生的各种方式

产生信号的方式：

1. 键盘产生
2. 进程异常产生
3. 系统调用产生
4. 软件条件产生

• 键盘产生

kill -l查看信号列表：

其中，ctrl+c结束进程的过程就是进程收到了二号信号。

我们可以通过signal函数来查看捕捉的信号编码：

这个函数的意思：signal是一个指针函数，它的两个参数为signum和handler，它的返回值为一个指针，该指针指向一个返回值为void，参数类型为int的函数。（没有看懂可以先记住用法，往下看，后面有详解）

相同的写法为:

void (*signal(int signum,sighandler_t handler))(int)

signal函数的参数：第一个signum代表你想要捕捉的信号的编号，第二个是一个函数指针，表示你设计的捕捉函数（用函数名直接表示）。

上面的sighandler_t是一个函数指针，该函数返回值为void，参数类型为int，也就是说这个捕捉函数的返回值必须为void，参数为int。

写一个代码来捕捉二号信号：

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
void hunter(int signum)
{
    printf("signum = %d\n",signum);
    exit(1);
}
int main()
{
    //捕捉2号信号
    signal(2,hunter);
    while(1){
       printf("example####\n");
       sleep(2);
    }
    return 0;
}

运行结果：

可以看见，当我们ctrl + c终止进程时，信号捕捉的结果就是二号信号。

但是当该进程变成后台进程，这种方式就无法成功终止该进程；因为信号的产生方式之一就是通过键盘产生信号，用来终止前台进程。

• 系统异常产生
• 产生方式

一般而言，进程收到信号的处理方案有三种情况：

1. 默认动作：终止自己或者暂停等
2. 忽略动作：是一种信号的处理方式，只不过方式是什么也不干
3. 自定义动作（信号的捕捉）：修改信号的处理方式由默认->自定义动作；例如上述信号捕捉方法。

值得注意的是，9号信号不可以被自定义，也就是说，9号信号不会被捕捉。

平时我们遇到的程序崩溃，其实也就是进程收到了信号导致的：进程收到11号信号（段错误）信号。

• 为什么进程会收到信号？

这是因为进程的错误导致了软硬件的错误被OS发现了，OS就向该进程发送信号。

• OS是如何处理异常退出后的进程？

在Linux中，当一个进程退出的时候，它的退出码和退出信号都会被设置；

当一个进程异常的时候，进程的退出信号会被设置，表明当前进程退出的原因；

如果必要，OS会设置退出信息中的core dump标志位，并将进程在内存中的数据转存到磁盘当中，方便我们后期调试。

所以这又说明了一点：程序崩溃也会产生信号。

• 通过系统调用产生

例如kill函数，kill命令就是通过调用kill函数执行的：

运行下列代码：

static void Usage(const char* proc)
{
    printf("Usage:%s,signo who\n",proc);
}
// 示例：./test signo who
int main(int argc,char* argv[])
{
    //如果格式不对就打印执行手册
    if(argc != 3){
       Usage(argv[0]);
       return 1;
    }
    int signo = atoi(argv[1]);//发什么信号：信号编号
    int who = atoi(argv[2]);//给谁发：进程号
    kill(who,signo);
    printf("signo:%d,who:%d\n",signo,who);
    return 0;
}

这个代码的作用是，通过修改命令行参数的方式，设置一个自己的标准，给谁发信号、发送什么信号；这里采用的是给某个进程发送kill -?信号，也即是说只要在运行这个程序以后，要输入想处理的进程、信号和进程号，就可以终止该进程。

也可以直接用raise函数直接给自己发任意信号：

上述两个函数的返回值都是成功返回0，否则返回-1；

还可以通过abort函数发某种确定的信号：

这个函数的用法是直接调用以后，会给该进程发送信号导致其异常终止，类似于exit函数，由于其总是成功，所以无返回值。

• 软件条件产生

#include <unistd.h>
unsigned int alarm(unsigned int seconds);

调用alarm函数可以设定一个闹钟,也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号, 该信号的默认处理动作是终止当前进程。

• 如何理解操作系统给进程发信号？

其实是OS给进程发送信号数据，这个操作是在task_struct完成的，本质是OS向指定进程的task_struct中的信号位图写入比特位1，即完成信号的发送相当于完成位图的写入。

3. 信号产生中

信号保存的方式

3.1 阻塞信号

1. 实际执行信号的处理动作称为信号递达(Delivery)

分别有三种：默认、忽略和自定义捕捉。

2. 信号从产生到递达之间的状态,称为信号未决(Pending)

本质是该信号被暂存在task_struct信号位图中，未决。

3. 进程可以选择阻塞 (Block )某个信号

本质是OS允许进程暂时屏蔽某个信号：

（1）该信号是未决的
（2）该信号不会被递达，直到解除阻塞

• 那么忽略和阻塞有区别吗？

忽略是已经递达，但是是一种处理方式；而阻塞没有递达，是一种独立状态。它们其实是不同阶段的一种概念。

4. 被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作
5. 注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作

3.2 信号屏蔽字

在task_struct中有这样的结构：

这张图的三个表要连起来看，也就是每一行的数据连起来看。

1. block表代表着该信号是否被阻塞

本质也是位图表，其比特位位置代表信号的编号，比特位里的内容代表该信号是否被阻塞。如果该信号被阻塞，那么就不会再看是否收到该信号；如果没有被阻塞，再进行后续判断。

2. pending表代表着是否收到该信号

3. handler表代表收到该信号后的处理方式，也就是上面说的信号位图；

它有两个宏：SIG_DFL（代表1，处理方式为忽略）和SIG_IGN（代表0，处理方式为默认），其实它们都是32位的无符号数宏，如果是自定义方式，那就填入自定义函数名。

从这里就可以更深入地理解到：signal函数的两个参数其实就是分别对应handler表索引，然后将函数地址或者对应宏填进去。

//回调函数类型必须遵照下列模型
typedef void (*sighandler_t)(int);
//返回值是上述函数指针
sighandler_t signal(int signum,sighandler_t handler);

4. 信号产生后

信号处理的方式

4.1 信号集操作函数

虽然是位图结构，但是OS并不允许用户直接对其进行修改，而是要通过对应接口。

从上述来看,每个信号只有一个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);//比特位全部置0
int sigfillset(sigset_t *set);//比特位全部置1
int sigaddset (sigset_t *set, int signo);//增加
int sigdelset(sigset_t *set, int signo);//删除
int sigismember（const sigset_t *set, int signo);//判断是否包含某种信号

函数sigemptyset初始化set所指向的信号集,使其中所有信号的对应bit清0,表示该信号集不包含任何有效信号。

函数sigfillset初始化set所指向的信号集,使其中所有信号的对应bit置1,表示该信号集的有效信号包括系统支持的所有信号。

注意,在使用sigset_ t类型的变量之前,一定要调用sigemptyset或sigfillset做初始化,使信号集处于确定的状态。 初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号。

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

4.2 sigprocmask函数

调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集)。

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);

返回值:若成功则为0,若出错则为-1

set是输入性参数，是指向信号集的指针，可以认为它就是新设置的信号集，设置为NULL表示只想读取现在的屏蔽值；

oset是输出型参数，是指向旧信号集的指针，即旧的信号集。

如果oset是非空指针,则读取进程的当前信号屏蔽字通过oset参数传出。如果set是非空指针,则 更改进程的信号屏蔽字,参数how指示如何更改。

如果oset和set都是非空指针,则先将原来的信号屏蔽字备份到oset里,然后根据set和how参数更改信号屏蔽字。

假设当前的信号屏蔽字为mask,以下是how参数的可选值：

（从命名就可以大概猜出）

1. SIG_BLOCK：set包含了我们希望添加到当前信号屏蔽字的信号，相当于mask = mask | set
2. SIG_UNBLOCK：set包含了我们希望从当前信号屏蔽字中解除阻塞的信号，相当于mask = mask ~ set
3. SIG_SETMASK：将set的值设定为新的进程屏蔽，相当于mask = set

写一个屏蔽2号信号的程序：

int main()
{
    sigset_t set,oset;
    //初始化
    sigemptyset(&set);
    sigemptyset(&oset);
    //往新信号集添加2号信号
    sigaddset(&set,2);
    //将set设置为新的屏蔽信号集
    sigprocmask(SIG_SETMASK,&set,&oset);
    while(1){
        printf("aaaaaaaa\n");
        sleep(1);
    }
    return 0;
}

运行结果：

很明显，此时的ctrl+c（2号信号）对该进程已经无效了

和信号捕捉一样，9号信号不能被屏蔽，如果可以的话这个进程就变成无敌进程了。

4.3 sigpending函数

这个函数并不是用来修改pending位图的，修改pending是OS做的事，这个函数只是单纯地获取pending位图：

int sigpending(sigset_t *set);//输出型参数

4.4 sigaction函数

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

sigaction函数可以读取和修改与指定信号相关联的处理动作。 调用成功则返回0,出错则返回- 1。

signo是指定信号的编号。act是一个结构体，是输入型参数，它表示将要对信号signo做的动作；oact也是结构体，是输出型参数，代表旧的信号数。

若act指针非空,则根据act修改该信号的处理动作。若oact指针非空,则通过oact传出该信号原来的处理动作。act和oact指向sigaction结构体。

• sigaction结构体

sa_handler是一个函数指针，其实也是和signal里的函数指针一样，待赋值后得到一个handler方法，执行对应方法：

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

所以可以根据这个原理捕捉二号信号：

void handler(int signo)
{
     printf("get a signal : %d\n",signo);
}
int main()
{
    struct sigaction act;
    act.sa_handler = handler;
    sigaction(2,&act,NULL);
    while(1){
      printf("aaaaaaaaa\n");
      sleep(1);
    }
    return 0;
}

运行结果：

参数设置：

将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号,赋值为常数SIG_DFL表示执行系统默认动作,赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册了一个信号处理函数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用。

act.sa_handler = SIG_IGN; //忽略
act.sa_handler = SIG_DFL; //默认

• 与signal函数的区别

当某个信号的处理函数被调用时,内核自动将当前信号加入进程的信号屏蔽字,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么 它会被阻塞到当前处理结束为止。

就像刚才运行代码，想要屏蔽2号信号的时候，会把2号信号加入进程的信号屏蔽字，这样就避免了重复捕捉。

如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字。

比如说刚才的代码，捕捉2号的同时也想屏蔽3号信号：

sigaddset(&act,sa_mask,NULL);

5. 信号是什么时候被处理的

信号并不是收到就直接处理的，而是在合适的时候，因为信号的产生是异步的，当前进程可能在做更重要的事情，OS会采用信号延时处理，而这个所谓合适的时候，是：

当进程从内核态返回到用户态的时候，进行上述的信号检测和处理工作。

这是因为信号是被保存在进程的PCB中的pending位图里面，进行处理（检测，递达（默认，忽略，自定义））。

所以说检测的时候是处于内核态的，因为这样才能去访问三个表结构。

内核态是指执行OS的代码和数据时，计算机所处的状态；OS代码的执行全部都是在 内核态。

用户态是指用户代码和数据被访问或者执行的时候所处的状态；我们自己写的代码全部都是在用户态执行的。

可以用下图来解释：

首先要知道，系统调用其实就是从用户态变成内核态的过程。

对于黑色箭头来说，就像是简单地执行了某个系统调用，比如open，所以就是切换内核态、系统调用、切换用户态和返回用户态的过程。

而对于红色箭头来说，是一次信号处理的过程，前两步和黑色箭头一样，切换、系统调用，但是下一步时就会检测该进程是否收到某种信号，这也就是上面说的 “内核态返回用户态的过程，进行信号检测工作”。

这个检测的过程是通过前面讲的block、pending、handler三个表完成的。

而返回的时候，并不是直接切换回用户态就行了。我们知道handler有三种方法，如果是默认或忽略，就对对应表进行操作，然后切换返回；如果是自定义处理的话，会切换到用户态调用handler方法，然后再切换为内核态调用返回方法。

下图是它的简化版：

这里有两个问题要说明：

1. 为什么OS要内核态切换为用户态，才去调用handler？

因为OS需要保护自己，不仅仅体现于不让别人轻易执行它的代码而设置系统调用接口，也体现于不轻易以内核态的身份执行别人的代码，因为不知道别人的代码是否含有有害信息。

2. 为什么执行完handler方法后不直接从用户态返回？

因为一开始就是从用户态的代码执行系统调用进入内核态的，如果此时执行完handler方法直接返回，就相当于从用户态代码跳转到用户态代码，不符合规定。