16、【Linux系统编程】信号详解

16、【Linux系统编程】信号详解
信号的基本概念

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

使用kill -l命令查看系统中定义的信号列表： 1-31是普通信号； 34-64是实时信号

所有的信号都由操作系统来发！

对信号的三种处理方式

1、忽略此信号：大多数信号都可使用这种方式进行处理，但有两种信号却决不能被忽略。它们是：SIGKILL和SIGSTOP。这两种信号不能被忽略的，原因是：它们向超级用户提供一种使进程终止或停止的可靠方法。另外，如果忽略某些由硬件异常产生的信号（例如非法存储访问或除以0），则进程的行为是示定义的。

2、直接执行进程对于该信号的默认动作 ：对大多数信号的系统默认动作是终止该进程。

3、捕捉信号：执行自定义动作（使用signal函数），为了做到这一点要通知内核在某种信号发生时，调用一个用户函数handler（信号处理函数）。在用户函数中，可执行用户希望对这种事件进行的处理。注意，不能捕捉SIGKILL和SIGSTOP信号。
```
1 #include <signal.h>
2 typedef void( *sighandler_t)(int);
3 sighandler_t signal(int signum, sighandler_t handler);
```
signal函数的作用：给某一个进程的某一个特定信号（标号为signum）注册一个相应的处理函数，即对该信号的默认处理动作进行修改，修改为handler函数所指向的方式。

1、第一个参数是信号的标号

2、第二个参数，sighandler_t是一个typedef来的，原型是void (*)(int)函数指针，int的参数会被设置成signum

【实例】
```
 1 #include<stdio.h>
 2 #include<signal.h>
 3 void handler(int sig)
 4 {
 5  printf("get a sig,num is %d
",sig);
 6 }
 7   
 8 int main()
 9 {
10  signal(2,handler);
11  while(1)
12  {
13   sleep(1);
14   printf("hello
");
15  }
16  return 0;
17 }
```
修改了2号信号（Ctrl-c）的默认处理动作为handler函数的内容，则当该程序在前台运行时，键入Ctrl-c后不会执行它的默认处理动作（终止该进程）

上述实例的执行结果：

信号的处理过程：

进程收到一个信号后不会被立即处理，而是在恰当时机进行处理！什么是适当的时候呢？比如说中断返回的时候，或者内核态返回用户态的时候（这个情况出现的比较多）。

信号不一定会被立即处理，操作系统不会为了处理一个信号而把当前正在运行的进程挂起（切换进程），挂起（进程切换）的话消耗太大了，如果不是紧急信号，是不会立即处理的。操作系统多选择在内核态切换回用户态的时候处理信号，这样就利用两者的切换来处理了（不用单独进行进程切换以免浪费时间）。

总归是不能避免的，因为很有可能在睡眠的进程就接收到信号，操作系统肯定不愿意切换当前正在运行的进程，于是就得把信号储存在进程唯一的PCB（进程管理块）当中。

产生信号的条件

1.用户在终端按下某些键时，终端驱动程序会发送信号给前台程序。

     例如：Ctrl-c产生SIGINT信号，Ctrl-产生SIGQUIT信号，Ctrl-z产生SIGTSTP信号

2.硬件异常产生信号。

     这类信号由硬件检测到并通知内核，然后内核向当前进程发送适当的信号。

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

3.一个进程调用kill(2)函数可以发送信号给另一个进程。

     可以用kill(1)命令发送信号给某个进程，kill(1)命令也是调用kill(2)函数实现的，如果不明确指定信号则发送SIGTERM信号，该信号的默认处理动作是终止进程。

信号的产生

1.通过终端按键产生信号

举个栗子：写一个死循环，前台运行这个程序，然后在终端键入Ctrl-c

　　当CPU正在执行这个进程的代码 , 终端驱动程序发送了一个 SIGINT 信号给该进程，记录在该进程的 PCB中，则该进程的用户空间代码暂停执行 ,CPU从用户态切换到内核态处理硬件中断。

　　从内核态回到用户态之前，会先处理 PCB中记录的信号 ,发现有一个 SIGINT 信号待处理, 而这个信号的默认处理动作是终止进程，所以直接终止进程而不再返回它的用户空间代码执行。

2.调用系统函数向进程发信号
```
#include<stdio.h>
int main()
{
 printf("get pid :%d circle ...
",getpid());
 while(1);
 return 0;
}
```
　　写一个上面的程序在后台执行死循环，并获取该进程的id，然后用kill命令给它发送SIGSEGV信号，可以使进程终止。也可以使用kill -11 5796,11是信号SIGSEGV的编号。

打开终端1，运行程序：

利用终端2,给进程发送信号

终端1 显示进程被core了：

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

raise函数可以给当前进程发送指定的信号 (自己给自己发信号 )
```
#include<signal.h>
int kill(pid_t pid,int signo);
int raise(int signo);
```
这两个函数都是成功返回0，错误返回-1.

除此之外，abort函数使当前进程接收到SIGABRT信号而异常终止。
```
1 #include<stdlib.h>
2 void abort(void);
```
就像 exit函数一样 ,abort 函数总是会成功的 ,所以没有返回值。

3.由软件条件产生信号
```
 1 #include<stdio.h>
 2   
 3 int main()
 4 {
 5  int count=0;
 6  alarm(1);
 7  while(1)
 8  {
 9  printf("%d
",count);
10  count++;
11  }
12  return 0;
13 }
```
　　通过实现以上代码，调用alarm函数可以设定一个闹钟,告诉内核在seconds秒之后给当前进程发SIGALRM信号, 该信号的默认处理动作是终止当前进程。

　　该程序会在1秒钟之内不停地数数,并打印计数器，1秒钟到了就被SIGALRM信号终止。由于电脑配置等的不同，每台电脑一秒钟之内计数值是不同的一般是不同的。
```
1 #include <unistd.h>
2 unsigned int alarm(unsigned int seconds);
```
　　alarm函数的返回值是0或上次设置闹钟剩余的时间。

阻塞信号

1.信号在内核中的表示：

信号递达delivery：实际执行信号处理信号的动作

信号未决pending：信号从产生到抵达之间的状态，信号产生了但是未处理

忽略：抵达之后的一种动作

阻塞block：收到信号不立即处理，被阻塞的信号将保持未决状态，直到进程解除对此信号的阻塞，才执行抵达动作

信号产生和阻塞没有直接关系抵达和解除阻塞没有直接关系！

进程收到一个信号后，不会立即处理，它会在恰当的时机被处理。

每个信号都由两个标志位分别表示阻塞和未决，以及一个函数指针表示信号的处理动作。

在上图的例子中,

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

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

　　3. SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler。阻塞信号集也叫作信号屏蔽字。

信号产生但是不立即处理，前提条件是要把它保存在pending表中，表明信号已经产生。

2.信号集操作函数
```
1 #include <signal.h>
2 int sigemptyset(sigset_t *set); //初始化set所指向的信号集，使所有信号的对应位清0
3 int sigfillset(sigset_t *set); //初始化set所指向的信号集，表示该信号集的有效信号包括系统支持的所有信号
4 int sigaddset(sigset_t *set, int signo); //在该信号集中添加有效信号
5 int sigdelset(sigset_t *set, int signo); //在该信号集中删除有效信号
6 int sigismember(const sigset_t *set, int signo); //用于判断一个信号集的有效信号中是否包含某种信号
```
参数解析：

sigset_t结构体的参数表示信号集，信号操作的时候都是以信号集合的方式进行操作，需要事先创建一个该结构体的对象，然后把想要操作的信号添加到信号集合对象当中去，signo就是信号的标号了

3.调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集)。
```
1 #include <signal.h>
2 int sigprocmask(int how, const sigset_t *set, sigset_t *oset);
```
　　一个进程的信号屏蔽字规定了当前阻塞而不能递送给该进程的信号集。调用函数sigprocmask可以检测或更改（或两者）进程的信号屏蔽字。如果调用sigprocmask解除了对当前若干个未决信号的阻塞,则在sigprocmask返回前,至少将其中一个信号递达。

参数解析：

how，有三个宏

     SIG_BLOCK      添加到block表当中去

     SIG_UNBLOCK 从block表中删除

     SIG_SETMASK 设置block表设置当前信号屏蔽字为set所指向的值

set表示新设置的信号屏蔽字，oset表示当前信号屏蔽字

处理方式：

      set 非空， oset 为NULL ：按照how指示的方法更改set指向信号集的信号屏蔽字。

      set 为NULL，oset 非空：读取oset指向信号集的信号屏蔽字，通过oset参数传出。

      set 和 oset 都非空：现将原来的信号屏蔽字备份到oset里，然后根据set和how参数更改信号屏蔽字。

4. sigpending读取当前进程的未决信号集,通过set参数传出
```
#include <signal.h>
int sigpending(sigset_t *set);
```
这是一个输出型参数，会把当前进程的pending表打印到传入的set集中。

实例验证上面几个函数：

一开始没有任何信号，所以pending表中全是0，我通过Ctrl+C传入2号信号，看到pending表中有2号被置位了，经过10秒取消阻塞，2号信号被处理（经过我自定义的函数）

Linux下捕捉信号

信号由三种处理方式：

     忽略

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

     捕捉信号

如果信号的处理动作是用户自定义函数，在信号递达时就调用这个自定义函数，这称为捕捉信号。

进程收到一个信号后不会被立即处理，而是在恰当时机进行处理！即内核态返回用户态之前 ！

但是由于信号处理函数的代码在用户空间，所以这增加了内核处理信号捕捉的复杂度。

内核实现信号捕捉的步骤：

      1、用户为某信号注册一个信号处理函数sighandler。

      2、当前正在执行主程序，这时候因为中断、异常或系统调用进入内核态。

      3、在处理完异常要返回用户态的主程序之前，检查到有信号未处理，并发现该信号需要按照用户自定义的函数来处理。

      4、内核决定返回用户态执行sighandler函数，而不是恢复main函数的上下文继续执行！（sighandler和main函数使用的是不同的堆栈空间，它们之间不存在调用和被调用的关系，是两个独立的控制流程）

      5、sighandler函数返回后，执行特殊的系统调用sigreturn从用户态回到内核态

      6、检查是否还有其它信号需要递达，如果没有则返回用户态并恢复主程序的上下文信息继续执行。

signal和sigaction是两个信号安装函数

signal

给某一个进程的某一个信号（标号为signum）注册一个相应的处理函数，即对该信号的默认处理动作进行修改，修改为handler函数指向的方式；
```
#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);<br>//即：<br>void (*signal(int, void(*)(int)))(int);
```
signal函数接受两个参数：一个整型的信号编号，以及一个指向用户定义的信号处理函数的指针。　　

此外，signal函数的返回值是一个指向调用用户定义信号处理函数的指针。

sigaction

sigaction函数可以读取和修改与指定信号相关联的处理动作。
```
 1 #include <signal.h>
 2 int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
 3 struct sigaction
 4 {
 5   void (*sa_handler)(int);  //信号处理方式
 6   void (*sa_sigaction)(int, siginfo_t *, void *); //实时信号的处理方式 暂不讨论
 7   sigset_t sa_mask; //额外屏蔽的信号
 8   int sa_flags;
 9   void (*sa_restorer)(void); 
10 };
```
signum是指定信号的编号。

处理方式：

     1、若act指针非空,则根据act结构体中的信号处理函数来修改该信号的处理动作。

     2、若oldact指针非空,则通过oact传出该信号原来的处理动作。

     3、现将原来的处理动作备份到oldact里，然后根据act修改该信号的处理动作。

（注：后两个参数都是输入输出型参数！）

将sa_handler三种可选方式：

     1、赋值为常数SIG_IGN传给sigaction表示忽略信号；

     2、赋值为常数SIG_DFL表示执行系统默认动作；

     3、赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册一个信号处理函数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。

（注：这是一个回调函数,不是被main函数调用,而是被系统所调用）

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

pause

pause函数使调用进程挂起直到有信号递达！
```
1 #include <unistd.h>
2 int pause(void);
```
处理方式：　

     如果信号的处理动作是终止进程,则进程终止,pause函数没有机会返回;

     如果信号的处理动作是忽略,则进程继续处于挂起状态,pause不返回;

     如果信号的处理动作是捕捉,则调用了信号处理函数之后pause返回-1,errno设置为EINTR。

     所以pause只有出错的返回值(类似exec函数家族)。错误码EINTR表示“被信号中断”。

举个栗子

     1、定义一个闹钟，约定times秒后，内核向该进程发送一个SIGALRM信号；

     2、调用pause函数将进程挂起，内核切换到别的进程运行；

     3、times秒后，内核向该进程发送SIGALRM信号，发现其处理动作是一个自定义函数，于是切回用户态执行该自定义处理函数；

     4、进入sig_alrm函数时SIGALRM信号被自动屏蔽,从sig_alrm函数返回时SIGALRM信号自动解除屏蔽。然后自动执行特殊的系统调用sigreturn再次进入内核,之后再返回用户态继续执行进程的主控制流程(main函数调用的mytest函数)。

     5、pause函数返回-1,然后调用alarm(0)取消闹钟,调用sigaction恢复SIGALRM信号以前的处理动作。
```
 1 #include<stdio.h>
 2 #include<signal.h>
 3 #include<unistd.h>
 4 void sig_alarm(int signum)
 5 {
 6     printf("I am a custom handler!
");
 7 }
 8 void mysleep(unsigned int times)
 9 {
10     //注册两个信号处理动作
11     struct sigaction new,old;
12     new.sa_handler=sig_alarm; //信号处理函数
13     sigemptyset(&new.sa_mask);//不屏蔽任何信号屏蔽字
14     new.sa_flags=0;
15 
16     //对SIGALRM 信号的默认处理动作修改为自定义处理动作
17     sigaction(SIGALRM,&new,&old);
18     alarm(times);
19     pause(); //挂起等待
20     alarm(1);
21     sleep(2);
22     alarm(0); //取消闹钟
23     //恢复SIGALRM 信号到默认处理动作
24     sigaction(SIGALRM,&old,NULL);
25     alarm(1);
26     sleep(2);
27 }
28 int main()
29 {
30     while(1)
31     {
32         mysleep(2);
33         printf("many seconds passed
");
34         printf("###################
");
35     }
36     return 0;
37 }
```
执行结果：

定义一个闹钟并挂起等待，收到信号后执行自定义处理动作，在没有恢复默认处理动作前，收到SIGALRM信号都会按照其自定义处理函数来处理。恢复自定义处理动作之后收到SIGALRM信号则执行其默认处理动作即终止进程！

实时信号与非实时信号

早期Unix系统只定义了32种信号，前32种信号已经有了预定义值，每个信号有了确定的用途及含义，并且每种信号都有各自的缺省动作。如按键盘的CTRL ^C时，会产生SIGINT信号，对该信号的默认反应就是进程终止。后32个信号表示实时信号，等同于前面阐述的可靠信号。这保证了发送的多个实时信号都被接收。

非实时信号都不支持排队，都是不可靠信号；实时信号都支持排队，都是可靠信号。

使用kill -l可以查看信号列表。可以看到Linux中系统一共支持64种信号。

1-31是普通信号（用于内核向进程通知事件。即传统或者标准信号，也称为不可靠信号）； 34-64是实时信号（可靠信号）。

0 号信号用来测试对应进程是否存在或者是否由权限给其发送信号

平时可以接触的是普通信号，其各个信号的含义如下：
1. SIGHUP ：当用户退出Shell时，由该Shell启的发所有进程都退接收到这个信号，默认动作为终止进程。
2. SIGINT ：用户按下组合键时，用户端时向正在运行中的由该终端启动的程序发出此信号。默认动作为终止进程。
3. SIGQUIT ：当用户按下组合键时产生该信号，用户终端向正在运行中的由该终端启动的程序发出此信号。默认动作为终止进程并产生core文件。
4. SIGILL ：CPU检测到某进程执行了非法指令。默认动作为终止进程并产生core文件。
5. SIGTRAP：该信号由断点指令或其他trap指令产生。默认动作为终止进程并产生core文件。
6. SIGABRT ：调用abort函数时产生该信号。默认动作为终止进程并产生core文件。
7. SIGBUS：非法访问内存地址，包括内存地址对齐（alignment）出错，默认动作为终止进程并产生core文件。
8. SIGFPE：在发生致命的算术错误时产生。不仅包括浮点运行错误，还包括溢出及除数为0等所有的算术错误。默认动作为终止进程并产生core文件。
9. SIGKILL ：无条件终止进程。本信号不能被忽略、处理和阻塞。默认动作为终止进程。它向系统管理员提供了一种可以杀死任何进程的方法。
10. SIGUSR1：用户定义的信号，即程序可以在程序中定义并使用该信号。默认动作为终止进程。
11. SIGSEGV：指示进程进行了无效的内存访问。默认动作为终止进程并使用该信号。默认动作为终止进程。
12. SIGUSR2：这是另外一个用户定义信号，程序员可以在程序中定义并使用该信号。默认动作为终止进程。
13. SIGPIPE ：Broken pipe：向一个没有读端的管道写数据。默认动作为终止进程。
14. SIGALRM ：定时器超时，超时的时间由系统调用alarm设置。默认动作为终止进程。
15. SIGTERM ：程序结束(terminate)信号，与SIGKILL不同的是，该信号可以被阻塞和处理。通常用来要求程序正常退出。执行Shell命令kill时，缺少产生这个信号。默认动作为终止进程。
16. SIGCHLD ：子程序结束时，父进程会收到这个信号。默认动作为忽略该信号。
17. SIGCONT：让一个暂停的进程继续执行。
18. SIGSTOP：停止(stopped)进程的执行。注意它和SIGTERM以及SIGINT的区别：该进程还未结束，只是暂停执行。本信号不能被忽略、处理和阻塞。默认作为暂停进程。
19. SIGTSTP：停止进程的动作，但该信号可以被处理和忽略。按下组合键时发出该信号。默认动作为暂停进程。
20. SIGTTIN：当后台进程要从用户终端读数据时，该终端中的所有进程会收到SIGTTIN信号。默认动作为暂停进程。
21. SIGTTOU：该信号类似于SIGTIN，在后台进程要向终端输出数据时产生。默认动作为暂停进程。
22. SIGURG ：套接字（socket）上有紧急数据时，向当前正在运行的进程发出此信号，报告有紧急数据到达。默认动作为忽略该信号。
23. SIGXCPU：进程执行时间超过了分配给该进程的CPU时间，系统产生该信号并发送给该进程。默认动作为终止进程。
24. SIGXFSZ：超过文件最大长度的限制。默认动作为yl终止进程并产生core文件。
25. SIGVTALRM：虚拟时钟超时时产生该信号。类似于SIGALRM，但是它只计算该进程占有用的CPU时间。默认动作为终止进程。
26. SIGPROF：类似于SIGVTALRM，它不仅包括该进程占用的CPU时间还抱括执行系统调用的时间。默认动作为终止进程。
27. SIGWINCH：窗口大小改变时发出。默认动作为忽略该信号。
28. SIGIO：此信号向进程指示发出一个异步IO事件。默认动作为忽略。
29. SIGPWR：关机。默认动作为终止进程。
信号实质上是软中断，中断有优先级，信号也有优先级。如果一个进程有多个未决信号，则对于同一个未决的实时信号，内核将按照发送的顺序来递送信号。如果存在多个未决信号，则值（或者说编号）越小的越先被递送。如果即存在不可靠信号，又存在可靠信号（实时信号），虽然POSIX对这一情况没有明确规定，但Linux系统和大多数遵循POSIX标准的操作系统一样，将优先递送不可靠信号。

Linux支持的信号列表如下。很多信号是与机器的体系结构相关的，首先列出的是POSIX.1中列出的信号：

信号值处理动作发出信号的原因
---------------------------------------------------------------------
SIGHUP 1 A 终端挂起或者控制进程终止
SIGINT 2 A 键盘中断（如break键被按下）
SIGQUIT 3 C 键盘的退出键被按下
SIGILL 4 C 非法指令
SIGABRT 6 C 由abort(3)发出的退出指令
SIGFPE 8 C 浮点异常
SIGKILL 9 AEF Kill信号
SIGSEGV 11 C 无效的内存引用
SIGPIPE 13 A 管道破裂: 写一个没有读端口的管道
SIGALRM 14 A 由alarm(2)发出的信号
SIGTERM 15 A 终止信号
SIGUSR1 30,10,16 A 用户自定义信号1
SIGUSR2 31,12,17 A 用户自定义信号2
SIGCHLD 20,17,18 B 子进程结束信号
SIGCONT 19,18,25 进程继续（曾被停止的进程）
SIGSTOP 17,19,23 DEF 终止进程
SIGTSTP 18,20,24 D 控制终端（tty）上按下停止键
SIGTTIN 21,21,26 D 后台进程企图从控制终端读
SIGTTOU 22,22,27 D 后台进程企图从控制终端写

下面的信号没在POSIX.1中列出，而在SUSv2列出

信号值处理动作发出信号的原因
--------------------------------------------------------------------
SIGBUS 10,7,10 C 总线错误(错误的内存访问)
SIGPOLL A Sys V定义的Pollable事件，与SIGIO同义
SIGPROF 27,27,29 A Profiling定时器到
SIGSYS 12,-,12 C 无效的系统调用 (SVID)
SIGTRAP 5 C 跟踪/断点捕获
SIGURG 16,23,21 B Socket出现紧急条件(4.2 BSD)
SIGVTALRM 26,26,28 A 实际时间报警时钟信号(4.2 BSD)
SIGXCPU 24,24,30 C 超出设定的CPU时间限制(4.2 BSD)
SIGXFSZ 25,25,31 C 超出设定的文件大小限制(4.2 BSD)

（对于SIGSYS，SIGXCPU，SIGXFSZ，以及某些机器体系结构下的SIGBUS，Linux缺省的动作是A (terminate)，SUSv2 是C (terminate and dump core)）。

下面是其它的一些信号

信号值处理动作发出信号的原因
---------------------------------------------------------------------
SIGIOT 6 C IO捕获指令，与SIGABRT同义
SIGEMT 7,-,7
SIGSTKFLT -,16,- A 协处理器堆栈错误
SIGIO 23,29,22 A 某I/O操作现在可以进行了(4.2 BSD)
SIGCLD -,-,18 A 与SIGCHLD同义
SIGPWR 29,30,19 A 电源故障(System V)
SIGINFO 29,-,- A 与SIGPWR同义
SIGLOST -,-,- A 文件锁丢失
SIGWINCH 28,28,20 B 窗口大小改变(4.3 BSD, Sun)
SIGUNUSED -,31,- A 未使用的信号(will be SIGSYS)

（在这里，- 表示信号没有实现；有三个值给出的含义为，第一个值通常在Alpha和Sparc上有效，中间的值对应i386和ppc以及sh，最后一个值对应mips。信号29在Alpha上为SIGINFO / SIGPWR ，在Sparc上为SIGLOST。）

处理动作一项中的字母含义如下
A 缺省的动作是终止进程
B 缺省的动作是忽略此信号
C 缺省的动作是终止进程并进行内核映像转储（dump core）
D 缺省的动作是停止进程
E 信号不能被捕获
F 信号不能被忽略

上面介绍的信号是常见系统所支持的。以表格的形式介绍了各种信号的名称、作用及其在默认情况下的处理动作。各种默认处理动作的含义是：

终止程序是指进程退出；忽略该信号是将该信号丢弃，不做处理；

停止程序是指程序挂起，进入停止状况以后还能重新进行下去，一般是在调试的过程中（例如ptrace系统调用）；

内核映像转储是指将进程数据在内存的映像和进程在内核结构中存储的部分内容以一定格式转储到文件系统，并且进程退出执行，这样做的好处是为程序员提供了方便，使得他们可以得到进程当时执行时的数据值，允许他们确定转储的原因，并且可以调试他们的程序。

注意信号SIGKILL和SIGSTOP既不能被捕捉，也不能被忽略。信号SIGIOT与SIGABRT是一个信号。可以看出，同一个信号在不同的系统中值可能不一样，所以建议最好使用为信号定义的名字，而不要直接使用信号的值
相关阅读:
如何使用pandas分析金融数据
 ubuntu16.04 安装cuda9.0+cudnn7.0.5+tensorflow+nvidia-docker配置GPU服务
 人人都懂区块链#华为云·寻找黑马程序员#
#华为云·寻找黑马程序员# 如何实现一个优雅的Python的Json序列化库
 【带着canvas去流浪（13）】用Three.js制作简易的MARVEL片头动画（下）#华为云·寻找黑马程序员#
【立即报名】解码AI大杀器：华为云GPU+Tensorflow 容器实战
 Tensorflow Serving Docker compose 部署服务细节(Ubuntu)
华为云EI人脸识别接口初探
 人人学IoT 助学思维导图
 基于netty4.x开发时间服务器
原文地址：https://www.cnblogs.com/Long-w/p/9566100.html