一、认识信号

1.1 生活角度的信号

在网上买了很多件商品，在等待不同商品快递的到来。但即使快递并没有到来，你也知道快递到了后应该如何处理快递，即你能"识别快递"

当快递到达目的地，你收到了快递到来的通知，但不一定要马上下楼取快递，也就是说取快递的行为并不是一定要立即执行，可以理解成在"在合适的时候去取"

在你收到快递到达的通知，再到你拿到快递期间，是有一个时间窗口的，在这段时间内你并没有拿到快递，但是你知道快递已经到了，即你"记住了有一个快递要去取"

当时间合适，顺利拿到快递后，就要开始处理快递了，而处理快递的方式有三种：1、执行默认动作（打开快递，使用商品）2、执行自定义动作（快递是帮别人买的，你要将快递交给他）3、忽略（拿到快递后，放在一边继续做自己的事）

快递到来的整个过程，对你来讲是异步的，因为你不能确定你的快递何时到达

1.2 技术角度的信号

#include <iostream>
#include <unistd.h>
int main()
{
  while (1) {
    std::cout << "hello signal!" << std::endl;
    sleep(1);
  }
  return 0;
}

为什么输入Ctrl + c之后本该死循环的进程会被终止呢？

实际上当用户按Ctrl+C时，这个键盘输入会产生一个硬中断，被操作系统获取并解释成信号（Ctrl+C被解释成2号信号），然后操作系统将2号信号发送给目标前台进程，当前台进程收到2号信号后就会退出。

可以使用signal()函数对2号信号进行捕捉，证明按Ctrl+C时进程确实收到了2号信号

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

#include <iostream>
#include <signal.h>
#include <unistd.h>
void handler(int signum) {
    std::cout << "get a signal : " << signum << std::endl;
}
int main()
{
    signal(2, handler);
    while (1) {
    std::cout << "hello signal!" << std::endl;
    sleep(1);
  }
    return 0;
}

注意：

Ctrl+C产生的信号只能发送给前台进程。在一个命令后面加个&就可以将其放到后台运行，此时Shell就不必等待进程结束就可直接接收新的命令

Shell可以同时运行一个前台进程和任意多个后台进程，只有前台进程才能接到类似于Ctrl + c这种控制键产生的信号

前台进程在运行过程中，随时都可能因按下Ctrl+C而产生一个信号。所以该进程的用户空间代码执行到任何地方都可能收到2号信号而终止，所以信号相对于进程的控制流程来说是异步的

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

1.3 信号的发送与记录

可以使用 kill -l 命令查看Linux中的信号列表

其中1~31号信号是普通信号，34~64号信号是实时信号，各有31个。

每个信号都有一个编号和一个宏定义名称：/usr/include/bits/signum.h

进程是如何记录信号的呢？

当一个进程接收到某种信号后，该信号被记录在该进程的进程控制块当中。通过一个32位的位图记录信号是否产生

其中bit位的位置代表信号的编号，而bit位的内容就代表是否收到对应信号，比如第6个bit位是1就表明收到了6号信号

信号是如何发送给进程的呢？

一个进程收到信号，本质就是该进程内的信号位图被修改了，即该进程的数据被修改了，而只有操作系统才有资格修改进程的数据，因为操作系统是进程的管理者。也就是说，信号的发送本质上就是操作系统直接去修改目标进程的task_struct中的信号位图。

1.4 常见信号处理方式

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

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

忽略该信号

可以使用 man 7 signal 查看各个信号的默认处理动作

二、产生信号

2.1 通过终端按键产生信号(核心转储)

通过上面了解到Ctrl + c可以终止前台进程，而Ctrl + \也可以。那么两者有什么区别吗？

Ctrl + c是向进程发送2号信号SIGINT，而Ctrl  +\是向进程发送3号信号SIGQUIT。这两个信号的默认处理动作Action是不一样的，2号信号是Term，而3号信号是Core。

Term和Core都代表着终止进程，但是Core在终止进程时会进行一个动作（核心转储）

什么是核心转储？

在云服务器中，核心转储是默认关闭的，可以使用 ulimit -a 查看当前资源限制的设定

core file size为0就说明此时核心转储是关闭的，可以使用 ulimit -c size设置core文件大小

注意： ulimit命令改变的是bash进程的Resource Limit，但test进程的PCB是由bash进程复制而来，所以也具有和bash进程相同的Resource Limit值

设置完core文件大小后相当于打开了核心转储，此时使用Ctrl + \终止进程会显示 core dumped

并且当前路径下出现了一个新文件，该文件以一串数字为后缀，那一串数字其实是发生本次核心转储的进程的PID

核心转储功能的作用

当我们的程序在运行过程中崩溃了，我们一般会通过调试来进行逐步查找程序崩溃的原因。而在某些特殊情况下，我们会用到核心转储，核心转储指的是操作系统在进程收到某些信号而终止运行时，将该进程地址空间的内容以及有关进程状态的其他信息转而存储到一个磁盘文件当中，这个磁盘文件也叫做核心转储文件，一般命名为core.pid。而核心转储的目的就是为了在调试时，方便问题的定位

#include <iostream>
#include <unistd.h>
int main()
{
    std::cout << "I am running!!!" << std::endl;
    sleep(3);
    int err = 10 / 0;//除0错误
    return 0;
}

上述程序发生除0错误，休眠3秒后就会崩溃

使用gdb对可执行程序进行调试，然后使用 core-file core文件 命令加载core文件，即可判断出该程序在终止时收到了8号信号，并且定位到了产生该错误的具体代码

core dump标志

wait()和waitpid()都有一个参数int* status，这是一个输出型参数，用于获取子进程的退出状态的。

status是一个整型变量，但应将status变量看作是一个存储信息的位图，status的不同bit位所代表的信息不同，具体细节如下（只讲解status低16个bit位）：

若进程是正常终止的，那么status的次低8位就表示进程的退出状态，即退出码。若进程是被信号所杀，那么status的低7位表示终止信号，而第8位比特位是core dump标志（用于表示进程终止时是否进行了核心转储）

打开Linux的核心转储功能。代码中父进程创建一个子进程，子进程所执行的代码中存在野指针问题，当子进程执行到*p = 100时，会被操作系统所终止并进行核心转储。此时父进程使用waitpid函数获取到子进程退出时的状态，根据status的第7个bit位就可得知子进程在被终止时是否进行了核心转储

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
using namespace std;
int main()
{
  if (fork() == 0) {//child
    std::cout << "I am running..." << std::endl;
    int *p = nullptr;
    *p = 100;//野指针
    exit(0);
  }
  //father
  int status = 0;
  waitpid(-1, &status, 0);
    std::cout << "exit_code:" << WEXITSTATUS(status) << std::endl;
    std::cout << "core_dump:" << WCOREDUMP(status) << std::endl;
    std::cout << "trem_signal:" << WTERMSIG(status) << std::endl;
  return 0;
}

说明发生了核心转储

2.2 通过系统函数向进程发送信号

2.2.1 kill()函数

可以使用kill命令向进程发送信号，也可以使用系统函数向进程发送信号，譬如kill()函数

int kill(pid_t pid, int sig);//向进程ID为pid的进程发送sig号信号
//若信号发送成功则返回0，否则返回-1并设置errno

可以使用kill()函数模拟实现一个kill命令

#include <iostream>
#include <cstdlib>
#include <vector>
#include <sys/types.h>
#include <signal.h>
void Usage(const char* str) {
    std::cout << "Usage : " << str << "pid signo" << std::endl;   
}
int main(int argc, char* argv[]) 
{
    if(argc < 3) {
        Usage(argv[0]);
    }
    int signum = atoi(argv[1]);
    std::vector<pid_t> v;
    for(int i = 2; i < argc; ++i) {
        v.push_back(atoi(argv[i]));
    }
    for(auto &e : v) {
        kill(e, signum);
    }
    return 0;
}

为了可执行程序在执行时不用带上路径，将当前路径临时导入环境变量PATH当中

2.2.2 raise()函数

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

int raise(int sig);//若信号发送成功则返回0，否则返回一个非零值

2.2.3 abort()函数

abort()函数可以给当前进程发送SIGABRT信号，使得当前进程异常终止

void abort(void);

#include <iostream>
#include <cstdlib>
#include <signal.h>
#include <unistd.h>
using namespace std;
void handler(int signum) {
    cout << "get a signal : " << signum << endl;
}
int main()
{
    signal(SIGABRT,handler);
    while(true) {
        sleep(1);
        abort();
    }
    return 0;
}

虽然对SIGABRT信号进行了捕捉，并且收到SIGABRT信号后执行了自定义方法，但进程依然异常终止

2.3 因软件条件产生信号

2.3.1 SIGPIPE信号

SIGPIPE信号是一种由软件条件产生的信号。当进程在使用管道通信时，读端进程将读端关闭，而写端进程还在一直向管道写入数据，那么写端进程就会收到SIGPIPE信号进而终止

#include <iostream>
#include <unistd.h>
#include <cstring>
#include <cstdlib>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;
int main()
{
    //使用pipe创建匿名管道
  int fd[2] = { 0 };
  if (pipe(fd) < 0) {
    perror("pipe");
    exit(1);
  }
  pid_t id = fork();
  if (id == 0) { //child
    close(fd[0]);
    const char* msg = "hello father, I am child...";
        for(int i = 0;i < 10; ++i) {
            write(fd[1], msg, strlen(msg));
      sleep(1);
        }
    close(fd[1]);
    exit(0);
  }
    else if(id > 0) { //father
        close(fd[1]);
      close(fd[0]);
      int status = 0;
      waitpid(id, &status, 0);
      cout << "child get signal:" << WTERMSIG(status) << endl; //打印子进程收到的信号
    }
    else {
        perror("fork error");
        exit(1);
    }
  return 0;
}

2.3.2 SIGALRM信号

调用alarm()函数可以设定闹钟，让操作系统在seconds秒之后给当前进程发送SIGALRM信号，SIGALRM信号的默认处理动作是终止进程

unsigned int alarm(unsigned int seconds);

返回值：

若调用alarm函数前，已设置过闹钟，则返回上一个闹钟时间的剩余时间，并且本次闹钟的设置会覆盖上一次闹钟的设置

若调用alarm函数前，进程没有设置闹钟，则返回值为0

//测试云服务器一秒时间内可以将一个变量累加到多大(存在大量IO)

//测试云服务器一秒时间内可以将一个变量累加到多大(存在大量IO)
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
int main()
{
  int count = 0;
  alarm(1);
  while (1) {
    count++;
    printf("count: %d\n", count);
  }
  return 0;
}

CPU都是每秒上亿级的运算，但这个结果相差甚远。

为什么呢？是因为与外设之间大量的IO和云服务本身要通过网络传输数据。

//减少IO后的代码
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
int count = 0;
void handler(int signum) {
    printf("get a signal: %d\n", signum);
    printf("count: %d\n", count);
    exit(0);
}
int main()
{
    signal(SIGALRM, handler);
  alarm(1);
  while (1) {
    count++;
  }
  return 0;
}

减少与外设的IO后，count由七万多提升至了五亿多

2.4 因硬件异常产生信号

当程序当中出现类似于除0、野指针、越界之类的错误时，进程在运行过程中会收到操作系统发来的信号从而终止，那操作系统是如何识别到一个进程触发了某种问题的呢？

CPU当中有一组寄存器被称为状态寄存器，它可用来标记当前指令执行结果的各种状态信息，如有无进位、有无溢出等。而操作系统是软硬件资源的管理者，在程序运行过程中，若操作系统发现CPU内的某个状态标志位被置位，而这次置位就是因为某种除0错误而导致的，那么此时操作系统就会马上识别到当前是哪个进程导致的该错误（发生这种运行时错误的一定是此时CPU调度的进程），并将所识别到的硬件错误包装成信号发送给目标进程。本质就是操作系统去找到这个进程的task_struct，并向该进程的位图中写入8信号，写入8号信号后这个进程就会在合适的时候被终止。

具体案例：野指针问题

#include <stdio.h>
int main() 
{
    printf("I am running!!!\n");
    int* ptr = NULL;
    *ptr = 100;
    return 0;
}

当要访问一个变量时，首先要先经过页表的映射，将虚拟地址转换成物理地址，然后才能进行相应的访问操作。

页表属于一种软件映射关系，而实际上在从虚拟地址到物理地址映射的时候还涉及到一个硬件MMU，它是一种负责处理CPU的内存访问请求的计算机硬件，映射工作就是由MMU完成的，现在MMU基本上都已经集成到CPU当中了。

MMU既然是硬件单元，那么它当然也有相应的状态信息。当访问错误的虚拟地址时，MMU在进行虚拟地址到物理地址的转换时就会出现错误，其会将对应的错误写入到自己的状态信息当中，此时硬件上的信息会立马被操作系统识别，进而向对应进程发送SIGSEGV信号

总结：

C/C++程序会崩溃，是因为程序当中出现的各种错误最终一定会在硬件层面上有所表现，进而会被操作系统识别到，然后操作系统就会发送相应的信号将当前的进程终止