上一节讨论了程序出错的几种类型，知道了某些错误是 linux 无法处理的，例如程序遇到 0 作除数就会崩溃退出。

linux 中的信号

现在相当多计算机的处理器都有硬件除法单元了，所以程序中的除法运算都由硬件完成。在遇到除数为 0 这种情况时，硬件会通知 linux 内核，内核则会向发生这种情况的程序发送适当的信号。

例如，对一个执行到除数为 0 的程序发送 SIGFPE 信号，或者向一个执行无效内存引用的程序发送 SIGSEGV 信号等等。

可以输入 kill -l 命令查看 linux 中的信号：

$ kill -l
 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP
 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR
31) SIGSYS 34) SIGRTMIN 35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3
38) SIGRTMIN+4 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7
58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX

可以看出，每种信号名都是以 SIG 开头的，我的机器上共有 64 种信号名。

很多条件都能产生信号，上面说的 0 做被除数，或者非法引用内存就是例子。再比如，为了结束一个陷入死循环的程序，可以在终端输入 ctrl+c，这时也会有 SIGINT（中断信号）产生。

linux 中的信号是典型的异步事件。产生信号的时间对于程序而言是不可知的，程序无法预测何时会有信号产生，不过程序可以处理信号。例如程序可以选择忽略信号，执行信号的默认处理动作，也可以执行自己定义的处理动作。

编写 C语言程序，忽略 linux 中的信号

先来看看下面这个程序：

#include <stdio.h>
#include <signal.h>
int main()
{
 char* s = NULL;
 *s = 3;
 printf("*s= %d\n", *s);
 return 0;
}

程序试图将 3 放入内存 NULL 处，之前我们就说过，NULL 附近是绝对不允许引用操作的，所以这个程序会引发一个段错误，编译执行：

# ./a.out 
Segmentation fault

这其实就是 linux 段错误信号（SIGSEGV）的默认处理动作——打印出 “Segmentation fault”并退出程序。使用 C语言函数 signal 可以方便的自定义信号处理动作，signal 函数的使用说明如下：

signal 第一个参数接收信号，第二个参数则是个回调函数，当第一个参数指定的信号产生时，回调函数将得以执行。现在来写C语言程序忽略段错误信号（SIGSEGV），请看代码：

#include <stdio.h>
#include <signal.h>
void signal_handle(int sig)
{
 printf("recieve signal: %d\n", sig);
}
int main()
{
 signal(SIGSEGV, signal_handle);
 char* s = NULL;
 *s = 3;
 printf("*s= %d\n", *s);
 return 0;
}

代码很简单，我们自定义了信号处理函数 signal_handle，该函数除了把信号打印出来，什么也没做。编译执行之，得到如下结果

# ./a.out 
....
recieve signal: 11
recieve signal: 11
recieve signal: 11
recieve signal: 11
recieve signal: 11
recieve signal: 11
recieve signal: 11
...

可以看出，signal 函数改变了 SIGSEGV 信号的处理动作，程序出现段错误时，将执行 signal_handle 函数。执行完 signal_handle 函数，回到产生信号的代码处，又会产生 SIGSEGV 信号，最终，程序将会不停的打印“recieve signal: 11”。

产生信号

按下 ctrl+c 可以结束掉上面疯狂打印recieve signal: 11”的程序。这是因为 ctrl+c 被按下后，将产生 SIGINT 信号，而我们并没有修改 SIGINT 信号的处理动作，系统将执行默认动作——结束掉程序。

使用C语言函数 raise，可以给程序自己发送信号。现在对上述代码的信号处理函数 signal_handle 做如下修改：

void signal_handle(int sig)
{
 printf("recieve signal: %d\n", sig);
 raise(SIGINT);
}

再次编译执行，得到如下结果：

# gcc t.c 
# ./a.out 
recieve signal: 11

这就与 signal_handle 函数打印出“recieve signal: 11”后，立刻按下 ctrl+c 是一样的。

发送信号

ctrl+c 只能尝试结束运行在当前终端的前台程序，如果后台程序失控了，或者别的终端里的程序失控了，该如何结束它呢？这时可以使用 kill 命令，向失去控制的程序发送结束信号，对应上表，得知 SIGINT 信号的编号为 2，所以可以输入下面的命令结束失控程序：

# kill -2 <失控程序pid>

对于上述疯狂打印 “recieve signal: 11”的程序来说，若想在另一个终端里结束掉它，可以先查询它的 pid：

# ps -A|grep a.out
31701 pts/0 00:00:00 a.out

得知它的 pid 为 31701，所以输入

# kill -2 31701

发现另一个终端里的失控程序被结束掉了。

对应到 C语言里，也是有 kill 函数的，它的说明如下：

它会向参数一指定的 pid 进程发送信号 sig。现在编写结束失控进程的 C语言程序：

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
int main(int argc, char* argv[])
{
 if(argc<2){
 printf("\n\tusage: %s pid\n", argv[0]);
 return 1;
 }
 long pid = atol(argv[1]);
 kill(pid, SIGINT);
 return 0;
}

编译之：

# gcc kill.c -o mykill

现在使用我们自己编写的程序向指定 pid 发送 SIGINT 信号，可以发现失控程序也被成功结束了。

注意事项

相信大家也都发现了，如果某个程序忽略了所有能够结束自己的信号，一旦它失控陷入死循环，除了重启系统就没有别的解决办法了。例如常用 ctrl+c 结束失控程序，但是若某个失控程序忽略了 SIGINT 信号，则 ctrl+c 无论如何也是没法结束掉它的。所以，编写C程序时，使用信号要经过谨慎的思考才行。

欢迎在评论区一起讨论，质疑。文章都是手打原创，每天最浅显的介绍C语言、linux等嵌入式开发，喜欢我的文章就关注一波吧，可以看到最新更新和之前的文章哦。