1. 信号的理解

 信号在我们的生活中十分常见，红绿灯🚦会给我发送信号，我们在识别到红绿灯的信号后也会做出相应的处理动作，前进或者停住。信号在程序中其实也十分常见，程序的异常终止往往都是因为接收到了信号。我们将信号的生命周期分为3个阶段：信号产生之前、信号产生时、信号处理方式。

1.1 信号产生之前

 信号在还没有产生时，对于进程来说，进程也一定知道在接收到信号之后该怎么做。
//进程内部一定能够识别“信号”，程序员在设计进程时，已经内置了处理方案。
 其实信号与进程的关系就是一种“异步关系”！
· 异步关系
进程在等待某件事的过程中，继续做自己的事情，不需要等待这一件事完成后再工作。
（与同步关系相反，同步关系是：在等待某件事的过程中，停下自己正在做的事情，直到等待的事情做完，再继续做自己做的事情）

1.2 信号产生时

 进程可能因为正在处理更重要的事情，而不会立即处理信号，它会等合适的时候去处理。
 //这里的合适的时候我会在后文解释。由于不会立即处理信号，此时则需要将信号保存记录下来

1.3 处理信号

处理信号的方式有3个
 <1> 采用默认行为
 <2> 自定义行为
 <3> 忽略信号（非常规，但也算是处理了信号）
 
问题：为什么要有信号？
 为了让进程具有解决突发事件的能力。（比如程序遇到野指针、数组越界、除零问题）
 

2. 信号的种类

 Linux中一共有62个信号。
从时间上分为：非实时信号和实时信号
从可靠性上分为：不可靠信号和可靠信号
  [1, 31] 这31个信号是“非实时信号”，也是“不可靠信号”
  [34, 64] 这31个信号是“实时信号”，也是“可靠信号”

//“可靠信号”与“不可靠信号”的区别在于：可靠信号克服了信号可能丢失的问题，并且它支持排队。不可靠信号就是不支持排队，所以可能会丢失。

这里介绍几种常用的信号：

(1) SIGHUP
 本信号在用户终端连接(正常或非正常)结束时发出, 通常是在终端的控制进程结束时, 通知同一session内的各个作业, 这时它们与控制终端不再关联。
2) SIGINT
 程序终止(interrupt)信号，可以通过输入Ctrl + c发送该信号，用于通知前台进程组终止进程。//注意！无法终止后台进程
3) SIGQUIT
 进程退出信号，可以通过输入Ctrl + \ 来发送该信号。
4) SIGILL
 执行了非法指令。通常是因为可执行文件本身出现错误，或者试图执行数据段。 堆栈溢出时也有可能产生这个信号。
6) SIGABRT
 调用abort函数生成的信号。
8) SIGFPE
 在发生致命的算术运算错误时发出。 不仅包括浮点运算错误， 还包括溢出及除数为0等其它所有的算术的错误。
9) SIGKILL
 本信号不能被捕捉、阻塞和忽略，用来杀死任意一个运行中的进程
11) SIGSEGV
 程序发生段错误时，就是接收到了这个信号。试图访问未分配给自己的内存, 或试图往没有写权限的内存地址写数据.
13) SIGPIPE
 管道破裂。这个信号通常在进程间通信产生，比如采用FIFO(管道)通信的两个进程，读管道没打开或者意外终止就往管道写，写进程会收到SIGPIPE信号。此外用Socket通信的两个进程，写进程在写Socket的时候，读进程已经终止。
14) SIGALRM
 时钟定时信号, 计算的是实际的时间或时钟时间. alarm函数使用该信号.
15) SIGTERM
 程序结束(terminate)信号, 与SIGKILL不同的是该信号可以被阻塞和处理。通常用来要求程序自己正常退出，shell命令kill缺省产生这个信号。如果进程终止不了，我们才会尝试SIGKILL。
17) SIGCHLD
 子进程结束时， 父进程会收到这个信号。
18) SIGCONT
 让一个停止(stopped)的进程继续执行。 本信号不能被阻塞. 可以用一个handler来让程序在由stopped状态变为继续执行时完成特定的工作。 例如, 重新显示提示符
19) SIGSTOP
 停止(stopped)进程的执行。本信号不能被捕捉, 阻塞和忽略。注意它和terminate以及interrupt的区别:该进程还未结束, 只是暂停执行.
20) SIGTSTP
 停止进程的运行，但该信号可以被处理和忽略。 可以通过输入Ctrl-Z来发送这个信号。

3. 捕捉信号

3.1 signal函数

	typedef void (*sighandler_t) (int);
	//sighandler_t是个函数指针类型

	sighandler_t signal(int signum, sighandler_t handler);

 signal函数是用来“注册”信号的，将signum对应的信号的处理操作改为handler函数。这个过程就是注册！也有种说法叫做“捕获信号”，只有传过来的信号满足你signal函数传入的信号时，才会调用你signal函数中注册该信号时所写的函数方法。
//也就是说，如果传入该进程的信号不是signal注册的，就会正常执行这个信号本来的功能。
参数：
 signum：代表传入的信号的值（几号信号）
 handler：handler是个函数指针，它的函数体内实现了signum对应的处理信号的操作。
作用：
 在使用signal函数去注册完某一个信号后，以后遇到该信号就会去调用signal函数中的handler方法了。但是有一些信号是不能被注册/捕获的。比如：9号信号，9号信号的作用就是去杀死进程，所以它是不能被捕获的。 #SIGKILL、SIGSTOP不能被捕捉、阻塞和忽略！
演示

 #include <iostream>                                                                               
 #include <unistd.h>    
 #include <signal.h>    
 using namespace std;    
 //信号处理函数
 void handler(int signal)    
 {    
   cout << "signal: " << signal << endl;    
 }    
     
 int main()    
 {    
   signal(2, handler);    //捕捉2号信号，通过Ctrl + c可以发送2号信号SIGINT
   while(1);    //死循环等待信号的发送
   return 0;    
 } 

3.2 sigaction函数

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

参数：
 signo：和signal函数的signum一样，都是表示要捕获的信号。
 act：类型是个struct sigaction。

sa_handler就是信号捕捉后的处理方法。
sa_mask：它是一个屏蔽信号集(我会在下文讲)，在调用该信号捕捉函数之前，这一信号集要加进进程的信号屏蔽字中。仅当从信号捕捉函数返回时再将进程的信号屏蔽字复位为原先值。
sa_flags：一般设置为0。下面是sa_flags的一些标志位设置。

SA_INTERRUPT 由此信号中断的系统调用不会自动重启
SA_RESTART 由此信号中断的系统调用会自动重启
SA_SIGINFO 提供附加信息，一个指向siginfo结构的指针以及一个指向进程上下文标识符的指针

sa_sigaction：实时信号的参数。
sa_restorer：这个参数是个已经废弃的数据域，不要使用！
 oact：输出型参数，用于保存原来的信号处理动作。
//sigaction和signal功能基本一样，就是参数多一些。能用signal的地方就用signal就好了。
演示

#include <iostream>    
#include <unistd.h>    
#include <signal.h>    
using namespace std;    
    
void handler(int signal)    
{    
  cout << "signal: " << signal << endl;    
}    
    
int main()    
{                                                                              
  struct sigaction newact;    
  newact.sa_handler = handler;    
  newact.sa_flags = 0;    
    
  sigaction(2, &newact, NULL);    
  while(1);    
  return 0;    
} 

4. 信号产生的方式

①：键盘 (Ctrl + c、Ctrl + z、Ctrl + \)
②：系统调用 (kill、raise、abort)
③：程序异常 (最终会表现在硬件层面上)
④：软件条件 (SIGPIPE、SIGALRM)
//虽然产生信号的方式有很多种，但是最终它们都会经由OS去发送信号

①：键盘
键盘上的有很多组合键能够发出对应的信号
Ctrl + C --> 2号信号 —> SIGINT
Ctrl + \ --> 3号信号 —> SIGQUIT
Ctrl + Z --> 20号信号—> SIGSTP

②：系统调用
<1>：kill函数

	int kill(pid_t pid, int sig);

给pid号进程发送sig信号。
参数：pid和sig往往通过命令行参数的形式传入程序中


<2>：raise函数

int raise(int sig);      <==>    kill(getpid(), sig);    //这两者等价

给自己(当前进程)发送sig信号。
<3>：abort函数

void abort(void);

给自己发送6号信号SIGABRT。作用是让进程终止(Terminal)。
//abort函数总是能够成功的，所以它没有返回值！

③：程序异常
 程序异常最终都会表现在硬件层面。OS在检测到硬件异常后，会找到发生异常的进程，然后给该进程发送信号。例如：当前进程执行了除零的指令，CPU的计算单元会产生异常，OS将这个异常解释为SIGFPE信号发送给出现错误的进程；再比如当前进程非法访问内存地址，此时MMU会产生异常，OS将这个异常解释为SIGSEGV信号发送给该进程。

④：软件条件
 由于当前“软件条件”不成熟，而产生了信号。
例如：SIGPIPE就是因为读端被关闭，所以OS给写端发送了SIGPIPE信号，将其杀死。还有SIGALRM
14) SIGALRM

	unsigned alarm(unsigned seconds);    //seconds中写的是秒数

几秒后会发送一个alarm信号给自己，该信号的默认处理动作是终止当前进程。
 如果没到秒数之前，进程就接收到了alarm信号，那么alarm函数的返回值就是剩余的秒数。如果正常运行完了，那么返回值就是0.
 
 

5. 保存信号

 我们在前面提到过，非实时信号是从1号~31号。这里面一共有31个信号，面对这个数字是不是有些想法了？没错，信号就是利用比特位去存储的，也就是使用到了位图！（位图就是一种借助比特位去存储数据的数据结构，它的主要功能就是判断某个位置对应的值是否存在，因为每个位置只有0和1这两种状态）
问题：如何理解一个进程接收到了信号？
 一个进程的task_struct中有指向信号位图的指针，信号位图是与进程相关联的。一个进程接收信号的本质其实就是将该进程task_struct所对应的信号位图的对应位置由数字0改为数字1，这样就表示该进程接收到了某个信号。
 
在理解信号详细的存储结构之前，我们先了解一下下面一组概念：
 信号递达：实际执行信号的处理动作，被称为信号递达(Delivery)
 信号未决：信号从产生到递达之间的状态，被称为信号未决(Pending)
 信号阻塞：信号被阻塞了(blocking)

5.1 信号在内核中的结构

注意：
 对于非实时信号[1, 31]，由于信号位图只能表示某个信号到底存不存在 (非0即1)，而不能统计次数。所以当一个信号在递达之前产生了多次，那么只计一次！
 对于实时信号[34, 64]，它们在递达之前产生多次的话，全都会记录下来，依次放在一个队列中。
 

5.2 信号集操作函数

· 信号集
 sigset_t就是信号集，它是一种类型，也就是说它可以像int一样去定义变量。
 从上面的信号的结构图来看，对于阻塞block和未决pending位图只有在含义上有所不同，因此，我们可以使用sigset_t类型去存储它们的信息，去表示某个信号是“有效”还是“无效”。
 对于阻塞block位图来说，sigset_t可以表示某个信号“被阻塞”还是“没被阻塞”。
 对于未决pending位图来说，sigset_t可以表示某个信号“处于未决状态”还是“不处于未决状态”。
//sigset_t被称为信号集，从而衍生出了阻塞信号集和未决信号集。阻塞信号集也可以被称为信号屏蔽字。

※注意※：
 sigset_t可以理解为无符号整形。但是不要直接对sigset_t类型的数据直接使用按位运算！
 因为不同的平台中OS对sigset_t的实现可能不同。我们要使用信号集操作函数去控制sigset_t类型的数据。

· 信号集操作函数

//包含于<signal.h>
int sigemptyset(sigset_t* set);
int sigfillset(sigset_t* set);
int sigaddset(sigset_t* set, int signo);          //向信号集set中添加signo信号
int sigdelset(sigset_t* set, int signo);          //删除set信号集中的signo信号
int sigismember(const sigset_t* set, int signo);  //判断set信号集中的signo信号是否有效

• 在使用sigset_t的数据前，要先用sigemptyset去初始化set所指向的信号集，使其中所有的信号对应的bit位全部清零，表示该信号集不包含任何 有效信号。
• sigfillset函数，初始化set所指向的信号集，使其中的所有信号的对应bit位置变为1，表示该信号集的有效信号包括系统支持的所有信号。
• 在使用sigset_t类型的变量之前，一定要确保调用过sigemptyset或sigfillset做初始化！
  注意(细节)：

 信号集操作函数，实际上操作的只是你在程序中定义的sigset类型的变量，并没有对进程中的阻塞标志位图或未决位图进行修改。我们接下来还需要使用系统调用接口将信号集变量set设置进 进程中！

· 阻塞信号集的操作

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

返回值：
 成功返回0；失败返回-1
参数：
 how：表示如何更改信号屏蔽字（又叫阻塞信号集），how有如下3种可选值：
SIG_BLOCK: set包含了我们希望添加到当前信号屏蔽字的信号，相当于mask = mask | set
SIG_UNBLOCK: set包含了我们希望从信号屏蔽字中解除阻塞的信号，相当于mask = mask & ~set
SIG_SETMASK: 设置当前信号屏蔽字的值为set所指向的值，相当于mask = set #就是赋值
 set：指向现在的信号集，如果只想读取现在的信号集，可以设置为NULL。
 oset：oset是个输出型参数，不想使用可以设置为NULL。它用于获取你想要更改的set，也就是我们能通过这个参数备份要修改的set值，如果下次想要复原，可以使用保存的这个oset值。
 
· 获取未决信号集

	int sigpending(sigset_t* set);

 set也是个输出型参数，用于读取当前的未决信号集。
 未决信号集是通过发送信号进而改变里面的值的，所以我们只能去获取未决信号集。
 
代码演示

//代码的功能：
//先给把2号信号加入到当前进程的信号屏蔽字。
//然后创建出一个子进程，让子进程在5s后解除对于2号信号的屏蔽
//与此同时，父进程在反复给子进程发送2号信号（并且进行非阻塞式的进程等待）
#include <iostream>                                                                                                                                                                                            
#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
using namespace std;

int main()
{
  sigset_t set;
  sigemptyset(&set);
  sigaddset(&set, 2); //将2号信号加入屏蔽集
  sigprocmask(SIG_BLOCK, &set, NULL); //给当前进程设置信号集

  pid_t id = fork();
  if(id == 0)
  {
    int cnt = 0;
    while(1)
    {
      ++cnt;
      if(cnt == 5)
      {
        //5s后解除子进程对2号信号的屏蔽
        //sigdelset(&set, 2);//这里可以不用删除，直接在sigpromask中使用SIG_UNBLOCK
        sigprocmask(SIG_UNBLOCK, &set, NULL);
      }

      cout << "child# " << endl;
      sleep(1);
    }
  }
  else 
  {
    int status = 0;
    while(1)
    {
      cout << "Father sent signal to child" << endl;
      kill(id, 2);  //给子进程发送2号信号
      sleep(1);
      
      waitpid(id, &status, WNOHANG);	//非阻塞式的等待子进程
      if(status)
      {
        cout << "Child signal: " << (status & 0x7F) << endl;  //打印子进程接收到的信号
        break;
      }
    }
  }
  return 0;
} 

6. 处理信号

信号的处理方式一共有3种：

1. SIG_DFL  //采用默认行为
2. SIG_IGN  //采用忽略处理
3. 自定义方法handler

在使用signal/sigaction函数中，可以向handler参数的位置传这三种参数。
 

6.1 处理信号的时机

我们前面提到了，处理信号是要等到“合适”的时候，那么"合适的时候"是什么时候？
 由“内核态”切换到 “用户态”的时候，进行信号的处理。

那么什么是内核态，什么是用户态呢？

6.1.1 用户态与内核态

内核态（Kernal Mode）：通常用来执行操作系统的代码，是一种权限非常高的状态
用户态（User Mode） ：用来执行普通用户的代码，是一种受监管的普通状态

· 特权级
Intel x86架构的CPU一共有0~4 四个特权级，其中0级最高，3级最低。对于UNIX/LINUX来说，只使用了0级特权级和3级特权级。
当程序运行在3级特权级的时候，就是处于用户态。
当程序运行在0级特权级上，就是处于内核态。

6.1.2 用户态与内核态的转化

“用户态”—> “内核态”
a. 进行系统调用
b. 时间片到了导致进程切换
c. 程序异常
d. 外围设备的中断

“内核态” —> “用户态”
a. 系统调用返回
b. 进程切换完毕
c. 处理完异常、中断等问题
 

6.2 处理信号的过程

面对这张图，我们可能不太容易理解从③到④这个操作，也就是为什么信号的处理为自定义行为的时候必须要切换回用户态呢？内核态的权限比用户态高，在用户态能执行的代码内核态也一定可以，为什么还要特地切回用户态呢？
 理论上是内核态可以去访问用户态的代码，但是在信号的处理中，绝对不能直接去访问用户态的代码！
 因为如果用户态的代码涉及到一些非法越权操作，在内核态时就会执行这种非法操作，这样就出问题了！所以必须切换到用户态去执行用户态的代码，这样出现越权操作就会报错，而不会去执行这种非法操作了。

阻塞信号&捕捉信号

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

void printsigset(sigset_t* set)//打印pending表
{
    int i = 0;
    for(i=1; i<=32; ++i)
    {   
        if(sigismember(set,i))//当前信号在信号集中
            putchar('1');
        else//当前信号不在信号集中
            putchar('0');
    }   
    puts("");//printf("\n");
}

int main()
{
    sigset_t s,p;
    sigemptyset(&s);//初始化信号集
    sigaddset(&s,2);//将2号信号设置为有效信号
    sigprocmask(SIG_BLOCK, &s, NULL);//屏蔽2号信号
    int i = 10;
    while(i--)
    {
        sigpending(&p);//获取当前进程的未决信号集
        printsigset(&p);//打印未决信号集
        if(i==7)
        {
            raise(2);//向本进程发送2号信号
        }
        if(i == 5)
        {
            sigprocmask(SIG_UNBLOCK, &s, NULL);//解除对2号信号的屏蔽
            printf("recober block bitmap\n");
        }
        sleep(1);
    }
    return 0;
}                       

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

void handler(int num)//捕捉信号
{
    printf("signo is %d\n",num);
    return;
}

int main()
{
    signal(2,handler);//捕捉2号信号
    signal(3,handler);//捕捉3号信号

    while(1)
    {   
        printf("this is youngmay\n");
        sleep(1);
    }   
    return 0;
}

struct sigaction {
               void     (*sa_handler)(int);//信号的处理动作
               void     (*sa_sigaction)(int, siginfo_t *, void *);
               sigset_t   sa_mask;//当正在执行信号处理动作时，希望屏蔽的信号。当处理结束后，自动解除屏蔽
               int        sa_flags;//一般为0
               void     (*sa_restorer)(void);
           };

（4）返回值：成功返回0，出错返回-1

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

void handler(int num)
{
    printf("signo is %d\n",num);
    return;
}

int main()
{
    struct sigaction act,oact;
    act.sa_handler = handler;//将信号处理动作设置为信号捕捉
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask,3);//屏蔽3号信号
    sigaction(2,&act,&oact);//自定义2号信号的处理动作
    sigaction(3,&act,&oact);//自定义3号信号的处理动作
    int i = 10; 
    while(i--)
    {
        printf("this is youngmay\n");
        if(i == 5)
        {
            sigaction(2,&oact,NULL);//恢复2号信号的默认处理动作
            oact.sa_handler = SIG_IGN;//将3号信号的处理动作设为忽略
            sigaction(3,&oact,NULL);
        }
        sleep(1);
    }
    return 0;
}                

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

void handler(int num)
{                                                                               
    ;   
}

unsigned int mysleep(unsigned int t)
{
    struct sigaction act,oact;//act为要设置闹钟信号的相关信息，oact保存闹钟信号>的原有相关信息
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);//处理闹钟信号时，不屏蔽其他信号
    sigaction(SIGALRM,&act,&oact);//捕捉闹钟信号
        
    alarm(t);//t秒之后向进程发送闹钟信号
    pause();//使进程挂起等待
    int ret = alarm(0);//取消闹钟,返回闹钟剩余秒数
    sigaction(SIGALRM,&oact,NULL);//恢复闹钟的默认处理动作
    return ret;//返回闹钟剩下的时间
}

int main()
{
    while(1)
    {
        printf("hi,i am youngmay\n");
        mysleep(1);
    }
    return 0;
}                            

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

void handler(int num)
{
    printf("signo is %d\n",num);
    return;
}

unsigned int mysleep(unsigned int t)
{
    struct sigaction act,oact;//act为要设置闹钟信号的相关信息，oact保存闹钟信号>的原有相关信息
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);//处理闹钟信号时，不屏蔽其他信号
    sigaction(SIGALRM,&act,&oact);//捕捉闹钟信号
        
    alarm(t);//t秒之后向进程发送闹钟信号
    pause();//使进程挂起等待
    int ret = alarm(0);//取消闹钟,返回闹钟剩余秒数
    sigaction(SIGALRM,&oact,NULL);//恢复闹钟的默认处理动作
    return ret;//返回闹钟剩下的时间
}

int main()
{
    signal(2,handler);//将2号信号的处理动作改为自定义函数
    printf("hello\n");
    unsigned int ret = mysleep(20);
    printf("return ret is %d\n",ret);
    return 0;
}