一.信号概念

1.1 信号是什么

对于 Linux来说，实际信号是软中断，许多重要的程序都需要处理信号。信号，为 Linux 提供了一种处理异步事件的方法。如：

用户输入命令,在Shell下启动一个前台进程。
. 用户按下Ctrl-C ,这个键盘输入产生一个硬件中断，被OS获取，解释成信号，发送给目标前台进程
. 前台进程因为收到信号，进而引起进程退出

注意

1. Ctrl-C 产生的信号只能发给前台进程。一个命令后面加个&可以放到后台运行,这样Shell不必等待进程结束就可以接受新的命令,启动新的进程。
2. Shell可以同时运行一个前台进程和任意多个后台进程,只有前台进程才能接到像 Ctrl-C 这种控制键产生的信号。
3. 前台进程在运行过程中用户随时可能按下 Ctrl-C 而产生一个信号,也就是说该进程的用户空间代码执行到任何地方都有可能收到 SIGINT 信号而终止,所以信号相对于进程的控制流程来说是异步(Asynchronous)的

只能通过kill 命令关闭后台进程

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

1.2 查看系统的信号

用kill -l命令可以察看系统定义的信号列表

每个信号都有一个编号和一个宏定义名称,这些宏定义可以在signal.h中找到,例如其中有定 义 #define

SIGINT 2 ，信号中【1 - 33】号是普通信号，34以上的是实时信号

对其中一些信号进行介绍：

• 1） SIGHUP：本信号在用户终端连接结束时(正常或非正常)发出。

• 2） SIGINT：程序终止(或中断，interrupt)信号，通常是Ctrl+c或Delete键(INTR字符)时发出。

• 3） SIGQUIT：与SIGINT类似，但由Ctrl+(QUIT字符)控制，进程收到该信号时会产生core文件，类似于一个程序错误信号。

• 4） SIGLL：执行了非法指令，通常是可执行文件本身错误。

• 9） SIGKILL：用来立即结束程序的运行，该信号不能被阻塞、处理或忽略。

• 16） SIGTERM：程序结束(terminate)信号，与SIGKILL不同的是该信号可以被阻塞或处理，shell命令的kill默认产生该信号。

• 19） SIGSTOP：停止(stopped)进程的执行，注意和terminate及interrupt的区别，该进程还未结束，只是暂停执行，该信号与SIGKILL一样不能被阻塞、处理或忽略。

查看各类型的信号的具体含义可以用过man 7 signal 命令来查看

man 7 signal

1.3 信号的处理方式

可选的处理动作有以下三种（用到sigaction函数),:

1. 忽略此信号。

2. 执行该信号的默认处理动作。

3. 提供一个信号处理函数,要求内核在处理该信号时切换到用户态执行这个处理函数,这种方式称为捕捉

(Catch)一个信号。

二.信号产生

2.1 通过终端按键产生信号

ctrl+c——2号信号： SIGINT

ctrl+——3号信号： SIGQUIT

ctrl- 发送 SIGQUIT 信号，SIGINT的默认处理动作是终止进程,SIGQUIT的默认处理动作是终止进程并且Core Dump,生成 core 文件。

首先解释什么是Core Dump。当一个进程要异常终止时,可以选择把进程的用户空间内存数据全部 保存到磁
盘上,文件名通常是core,这叫做Core Dump。进程异常终止通常是因为有Bug,比如非法内存访问导致段错误,
事后可以用调试器检查core文件以查清错误原因,这叫做Post-mortem Debug（事后调试）。一个进程允许
产生多大的core文件取决于进程的Resource Limit(这个信息保存 在PCB中)。默认是不允许产生core文件的,
因为core文件中可能包含用户密码等敏感信息,不安全。在开发调试阶段可以用ulimit命令改变这个限制,允许
产生core文件。 首先用ulimit命令改变Shell进程的Resource Limit,允许core文件最大为1024K: $ ulimit -c
1024

这个core dump标志就是来看是否发生了核心转储，信号详情中带有core的就是该发生该信号是能进行核心转储

核心转储就是当进程出现某种异常时，是否有OS将当前进程在内存中的核心数据转存到磁盘，主要是为了调试

这里ctrl+使用没有生成core文件，这是因为一般的云服务器的核心转储功能是关闭的。可以使用ulimit -a去验证

如果我们想打开这个功能呢，可以用ulimit -c 去修改，让它能发生核心转储（注意，这个打开是临时的，当你关闭云服务器的终端后，又会默认变为0）

这样后就能发生核心转储

那么核心转储调试是什么样的

core在gdb中使用

2.2 调用系统函数向进程发信号

kill命令是调用kill函数实现的。kill函数可以给一个指定的进程发送指定的信号。

kill函数

#include <signal.h>
int kill(pid_t pid, int signo);
int raise(int signo);
这两个函数都是成功返回0,错误返回-1。

raise函数可以给当前进程发送指定的信号(自己给自己发信号)。

raise函数：int raise(int sig)
功能：给当前进程发送指定信号（自己给自己发信号），raise(signo)相当于kill(getpid(),signo)
返回值：成功返回0；失败返回非0值

abort函数使当前进程接收到信号而异常终止。(自己终止自己)

#include <stdlib.h>
void abort(void);
就像exit函数一样,abort函数总是会成功的,所以没有返回值

系统调用接口如何理解呢，

2.3 软件条件产生信号

有两个进程通过管道进行通信，如果读端进程关闭了自己的读接口，操作系统不会让写端进程一直写，因为写了没有意义，所以操作系统会给写端进程发送13号信号(SIGPIPE)，写端进程收到信号后就执行默认动作退出了。像这种只是因为读端关闭了这一软件条件触发的信号，我们称为软件条件产生信号。

alarm函数

#include <unistd.h>
unsigned int alarm(unsigned int seconds);
调用alarm函数可以设定一个闹钟,也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号, 该信号的默认处理动
作是终止当前进程

这个函数的返回值是0或者是以前设定的闹钟时间还余下的秒数。打个比方,某人要小睡一觉,设定闹钟为30分钟之后响,20分钟后被人吵醒了,还想多睡一会儿,于是重新设定闹钟为15分钟之后响,“以前设定的闹钟时间还余下的时间”就是10分钟。如果seconds值为0,表示取消以前设定的闹钟,函数的返回值仍然是以前设定的闹钟时间还余下的秒数

2.4 硬件异常产生信号

硬件异常被硬件以某种方式被硬件检测到并通知内核,然后内核向当前进程发送适当的信号。

例如当前进程执行了除以0的指令,CPU的运算单元会产生异常,内核将这个异常解释 为SIGFPE信号发送给进程。再比如当前进程访问了非法内存地址,,MMU会产生异常,内核将这个异常解释为SIGSEGV信号发送给进程

2.5 信号产生总结

• 上面所说的所有信号产生，最终都要有OS来进行执行，因为OS是进程的管理者

• 信号的处理在合适的时候处理的

• 信号如果不是被立即处理，那么信号需要暂时被进程记录下来，记录在PCB中

• 一个进程在没有收到信号的时候能知道自己应该对合法信号作何处理，程序员默认在系统中写好的

• 理解OS向进程发送信号：OS直接修改目标进程的PCB信号位图

三.阻塞信号

3.1 信号其他相关常见概念

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

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

• 进程可以选择阻塞 (Block )某个信号。

• 被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作.

• 注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作

3.2 信号在内核中的表示

• block集（阻塞集、屏蔽集）：一个进程所要屏蔽的信号，在对应要屏蔽的信号位置1

• pending集（未决信号集）：如果某个信号在进程的阻塞集之中，则也在未决集中对应位置1，表示该信号不能被递达，不会被处理

• handler（信号处理函数集）：表示每个信号所对应的信号处理函数，当信号不在未决集中时，将被调用每个信号都有两个标志位分别表示阻塞和未决，还有一个函数指针表示处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志。

在上图的例子中，

SIGHUP信号未阻塞也未产生过，当它递达时执行默认处理动作。

SIGINT信号产生过，但正在被阻塞，所以暂时不能递达。虽然它的处理动作是忽略，但在没有解除阻塞之前不能忽略这个信号，因为进程仍有机会改变处理动作之后再解除阻塞。

SIGQUIT信号未产生过，一旦产生SIGQUIT信号将被阻塞，它的处理动作是用户自定义函数sighandler。

3.3 sigset_t 与 信号集操作函数

未决和阻塞标志可以用相同的数据类型sigset_t来存储，sigset_t称为信号集，这个类型可以表示每个信号的“有效”或“无效”状态，，在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞，而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。阻塞信号集也叫做当前进程的信号屏蔽字（Signal Mask），这里的“屏蔽”应该理解为阻塞而不是忽略。

信号集及信号集操作函数：信号集被定义为一种数据类型：

typedef struct {
　　unsigned long sig[_NSIG_WORDS]；
} sigset_t

信号集操作函数

sigemptyset：

#include <signal.h>
int sigemptyset(sigset_t *set);
功能：清空集合数据，使其中所有信号的对应bit清零，表示该信号集不包含任何有效信号，防止出现意外；

sigemptyset：

#include <signal.h>
int sigemptyset(sigset_t *set);
功能：清空集合数据，使其中所有信号的对应bit清零，表示该信号集不包含任何有效信号，防止出现意外；

sigfillset：

#include <signal.h>
int sigfillset(sigset_t *set);
功能：初始化set所指向的信号集,使其中所有信号的对应bit置位,表示 该信号集的有效信号包括系统支持的所有信号。

sigaddset：

#include <signal.h>
int sigaddset(sigset_t *set, int signum);
功能：向set集合中添指定的signum信号。

sigdelset：

#include <signal.h>
int sigdelset(sigset_t *set, int signum);
功能：在set集合中删除指定的signum信号。

sigpending：

#include <signal.h>
int sigpending(sigset_t *set);
功能：将当前pending集合（信号注册集合）中的不处理（阻塞信号）信号取出来放到set中；

这四个函数都是成功返回0,出错返回-1

sigismember：

#include <signal.h>
int sigismember(const sigset_t *set, int signum);
功能：判断指定信号是否存在于指定集合中，存在返回真，不存在返回假。

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

3.3.1 sigprocmask

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

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);
返回值:若成功则为0,若出错则为-1

首先，若oset是非空指针，那么进程的当前信号屏蔽字通过oset返回。

其次，若set是一个非空指针，则参数how指示如何修改当前信号屏蔽字。

如果调用sigprocmask解除了对当前若干个未决信号的阻塞,则在sigprocmask返回前,至少将其中一个信号递达

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


int main()
{
  sigset_t set;
  sigset_t oset;

  sigemptyset(&set);//位图置空
  sigemptyset(&oset);

  sigaddset(&set,2);//将2号信号添加到位图
  sigprocmask(SIG_SETMASK,&set,&oset);//通过set修改信号屏蔽字
  int i = 0;
  while(1)
  {
    std::cout<<i++<<std::endl;
    sleep(1);
  }
  return 0; 
}

运行效果：

注意：不能阻塞SIGKILL和SIGSTOP信号。

3.3.2 sigpending

#include <signal.h>
int sigpending(sigset_t *set);
读取当前进程的未决信号集,通过set参数传出。调用成功则返回0,出错则返回-1。

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

using namespace std;
static void showPending(sigset_t *pending)
{
     for(int sig = 1 ; sig <= 31 ; sig++)
    {
        if(sigismember(pending ,sig))
            std::cout<<"1";
        else 
            std::cout<<"0";
    }
    std::cout << std::endl;
}


void handler(int signum)
{
    cout<<"获得了一个信号: "<< signum << endl;
    sigset_t pending;
    int c = 10; 
    while(true)
    {
        sigpending(&pending);//读取当前未决信号集
        showPending(&pending);
        c--;
        if(c == 0)
        {break;}
        sleep(1);
    }
}

int main()
{
    signal(2 , SIG_IGN);//将二号信号设置为忽视
    cout<<"getpid: "<<getpid()<<endl;
    //内核数据类型，我们这里使用是在用户栈定义的
    struct sigaction act,oact;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    act.sa_handler = handler;

    //在处理指定信号时下面的信号就会被屏蔽，直到指定的信号处理完
    //这里的是2号信号在处理
    sigaddset(&act.sa_mask,3);//
    sigaddset(&act.sa_mask,4);
    sigaddset(&act.sa_mask,5);
    sigaddset(&act.sa_mask,6);
    sigaddset(&act.sa_mask,7);

    //我们需要设置进当前调用的进程pcd中
    sigaction(2 , &act , &oact);

    cout << "default action : " << (int)(oact.sa_handler) << endl;

    while(true) sleep(1);
    return 0;
}

3.4 捕捉信号

3.4.1. 内核如何实现信号的捕捉

如果信号的处理动作是用户自定义函数,在信号递达时就调用这个函数,这称为捕捉信号。由于信号处理函数的代码是在用户空间的,处理过程比较复杂,举例如下: 用户程序注册了SIGQUIT信号的处理函数sighandler。 当前正在执行main函数,这时发生中断或异常切换到内核态。 在中断处理完毕后要返回用户态的main函数之前检查到有信号SIGQUIT递达。 内核决定返回用户态后不是恢复main函数的上下文继续执行,而是执行sighandler函 数,sighandler和main函数使用不同的堆栈空间,它们之间不存在调用和被调用的关系,是 两个独立的控制流程。 sighandler函数返回后自动执行特殊的系统调用sigreturn再次进入内核态。 如果没有新的信号要递达,这次再返回用户态就是恢复main函数的上下文继续执行了

3.5 sigaction

函数原型：sigaction函数的功能是检查或修改与指定信号相关联的处理动作（可同时两种操作）

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

signo参数指出要捕获的信号类型，act参数指定新的信号处理方式，oact参数输出先前信号的处理方式（如果不为NULL的话）。

sigaction函数可以读取和修改与指定信号相关联的处理动作。调用成功则返回0,出错则返回- 1。signo是指定信号的编号。若act指针非空,则根据act修改该信号的处理动作。若oact指针非 空,则通过oact传出该信号原来的处理动作。act和oact指向sigaction结构体:
将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号,赋值为常数SIG_DFL表示执行系统默认动作,赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册了一个信号处理函 数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用

当某个信号的处理函数被调用时,内核自动将当前信号加入进程的信号屏蔽字,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么 它会被阻塞到当前处理结束为止。 如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字

struct sigaction结构体介绍

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

• sa_handler此参数和signal()的参数handler相同，代表新的信号处理函数

• sa_mask 用来设置在处理该信号时暂时将sa_mask 指定的信号集搁置

• sa_flags 用来设置信号处理的其他相关操作，下列的数值可用。

• SA_RESETHAND：当调用信号处理函数时，将信号的处理函数重置为缺省值SIG_DFL

• SA_RESTART：如果信号中断了进程的某个系统调用，则系统自动启动该系统调用

• SA_NODEFER ：一般情况下， 当信号处理函数运行时，内核将阻塞该给定信号。但是如果设置了SA_NODEFER标记， 那么在该信号处理函数运行时，内核将不会阻塞该信号

3.5可重入函数

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

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

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

• 调用了malloc或free,因为malloc也是用全局链表来管理堆的。

• 调用了标准I/O库函数。标准I/O库的很多实现都以不可重入的方式使用全局数据结构

3.6 volatile

volatile 作用：保持内存的可见性，告知编译器，被该关键字修饰的变量，不允许被优化，对该变量

的任何操作，都必须在真实的内存中进行操作

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


using namespace std;

volatile int flag =  0;

void changeFlag(int signum)
{
    (void)signum;
    cout <<"change flag: " << flag;
    flag = 1;
    cout << "->" << flag << endl; 
}
int main()
{
    signal(2,changeFlag);
    while(!flag);
    cout<<"进程正常退出后： "<< flag << endl;
    return 0;
}

标准情况下，键入 CTRL-C ,2号信号被捕捉，执行自定义动作，修改 flag＝1 ， while 条件不满足,退出循环，进程退出

优化后

我们看到即使flag变为1，但是进程也没退出，这是因为加上优化后由于我们main函数中没有一句是修改flag的语句，编译器会直接将flag的值存入寄存器中，在每次使用flag时直接从寄存器中获取，不再去访问内存，即使在发送2号信号将内存中的内容修改后，依旧会访问寄存器中的值导致一直循环，CPU无法看到内存， 引起了内存被遮盖的情况

想要解决这个问题就需要用volatile

3.7 SIGCHLD信号

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

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

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