Linux系统编程——进程间通信：信号中断处理

什么是信号？

信号是 Linux 进程间通信的最古老的方式。信号是软件中断，它是在软件层次上对中断机制的一种模拟，是一种异步通信的方式 。信号可以导致一个正在运行的进程被另一个正在运行的异步进程中断，转而处理某一个突发事件。

“中断”在我们生活中经常遇到，譬如，我正在房间里打游戏，突然送快递的来了，把正在玩游戏的我给“中断”了，我去签收快递( 处理中断 )，处理完成后，再继续玩我的游戏。这里我们学习的“信号”就是属于这么一种“中断”。我们在终端上敲“Ctrl+c”，就产生一个“中断”，相当于产生一个信号，接着就会处理这么一个“中断任务”（默认的处理方式为中断当前进程）。

信号可以直接进行用户空间进程和内核空间进程的交互，内核进程可以利用它来通知用户空间进程发生了哪些系统事件。

一个完整的信号周期包括三个部分：信号的产生，信号在进程中的注册，信号在进程中的注销，执行信号处理函数。如下图所示：

注意：这里信号的产生，注册，注销时信号的内部机制，而不是信号的函数实现。

linux 可使用命令：kill -l（"l" 为字母）,查看相应的信号。

列表中，编号为 1 ~ 31 的信号为传统 UNIX 支持的信号，是不可靠信号（非实时的），编号为 32 ~ 63 的信号是后来扩充的，称做可靠信号（实时信号）。不可靠信号和可靠信号的区别在于前者不支持排队，可能会造成信号丢失，而后者不会。非可靠信号一般都有确定的用途及含义,  可靠信号则可以让用户自定义使用。更多详情，请看《Linux信号列表》。

信号的产生方式

1）当用户按某些终端键时，将产生信号。

终端上按“Ctrl+c”组合键通常产生中断信号 SIGINT，终端上按“Ctrl+\”键通常产生中断信号 SIGQUIT，终端上按“Ctrl+z”键通常产生中断信号 SIGSTOP 等。

2）硬件异常将产生信号。

除数为 0，无效的内存访问等。这些情况通常由硬件检测到，并通知内核，然后内核产生适当的信号发送给相应的进程。

3）软件异常将产生信号。

当检测到某种软件条件已发生，并将其通知有关进程时，产生信号。

4）调用 kill() 函数将发送信号。

注意：接收信号进程和发送信号进程的所有者必须相同，或发送信号进程的所有者必须是超级用户。

5）运行 kill 命令将发送信号。

此程序实际上是使用 kill 函数来发送信号。也常用此命令终止一个失控的后台进程。

信号的常用操作

发送信号

所需头文件：

#include <sys/types.h>

#include <signal.h>

int kill(pid_t pid, int signum);

功能：

给指定进程发送信号。

注意：使用 kill() 函数发送信号，接收信号进程和发送信号进程的所有者必须相同，或者发送信号进程的所有者是超级用户。

参数：

pid: 取值有 4 种情况:

pid > 0: 将信号传送给进程 ID 为pid的进程。

pid = 0: 将信号传送给当前进程所在进程组中的所有进程。

pid = -1: 将信号传送给系统内所有的进程。

pid < -1: 将信号传给指定进程组的所有进程。这个进程组号等于 pid 的绝对值。

signum: 信号的编号，这里可以填数字编号，也可以填信号的宏定义，可以通过命令 kill -l ("l" 为字母)进行相应查看。

返回值：

成功：0

失败：-1

下面为测试代码，本来父子进程各自每隔一秒打印一句话，3 秒后，父进程通过 kill() 函数给子进程发送一个中断信号 SIGINT（ 2 号信号），最终，子进程结束，剩下父进程在打印信息：

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <unistd.h>  
4. #include <sys/types.h>  
5. #include <signal.h>  
6.   
7. int main(int argc, char *argv[])  
8. {  
9.     pid_t pid;  
10.     int i = 0;  
11.   
12.     pid = fork(); // 创建进程  
13.     if( pid < 0 ){ // 出错  
14.         perror("fork");  
15.     }  
16.       
17.     if(pid == 0){ // 子进程  
18.         while(1){  
19.             printf("I am son\n");  
20.             sleep(1);  
21.         }  
22.     }else if(pid > 0){ // 父进程  
23.         while(1){  
24.             printf("I am father\n");  
25.             sleep(1);  
26.               
27.             i++;  
28.             if(3 == i){// 3秒后  
29.                 kill(pid, SIGINT); // 给子进程 pid ，发送中断信号 SIGINT  
30.                 // kill(pid, 2); // 等级于kill(pid, SIGINT);  
31.             }  
32.         }  
33.     }  
34.   
35.     return 0;  
36. }  

运行结果如下：

等待信号

所需头文件：

#include <unistd.h>

int pause(void);

功能：

等待信号的到来（此函数会阻塞）。将调用进程挂起直至捕捉到信号为止，此函数通常用于判断信号是否已到。

参数：

无。

返回值：

直到捕获到信号才返回 -1，且 errno 被设置成 EINTR。

测试代码如下：

[cpp] view plain copy

1. #include <unistd.h>  
2. #include <stdio.h>  
3.   
4. int main(int argc, char *argv[])  
5. {  
6.     printf("in pause function\n");  
7.     pause();  
8.       
9.     return 0;  
10. }  

没有产生信号前，进程一直阻塞在 pause() 不会往下执行，假如，我们按“Ctrl+c”，pause() 会捕获到此信号，中断当前进程。

处理信号

一个进程收到一个信号的时候，可以用如下方法进行处理：

1）执行系统默认动作

对大多数信号来说，系统默认动作是用来终止该进程。

2）忽略此信号

接收到此信号后没有任何动作。

3）执行自定义信号处理函数

用用户定义的信号处理函数处理该信号。

注意：SIGKILL 和 SIGSTOP 不能更改信号的处理方式，因为它们向用户提供了一种使进程终止的可靠方法。

产生一个信号，我们可以让其执行自定义信号处理函数。假如有函数 A, B, C，我们如何确定信号产生后只调用函数 A，而不是函数 B 或 C。这时候，我们需要一种规则规定，信号产生后就调用函数 A，就像交通规则一样，红灯走绿灯行，信号注册函数 signal() 就是做这样的事情。

所需头文件：

#include <signal.h>

typedef void (*sighandler_t)(int)；// 回调函数的声明
sighandler_t signal(int signum,sighandler_t handler);

功能：

注册信号处理函数（不可用于 SIGKILL、SIGSTOP 信号），即确定收到信号后处理函数的入口地址。此函数不会阻塞。

参数：

signum：信号的编号，这里可以填数字编号，也可以填信号的宏定义，可以通过命令 kill -l ("l" 为字母)进行相应查看。

handler: 取值有 3 种情况：

SIG_IGN：忽略该信号
SIG_DFL：执行系统默认动作
信号处理函数名：自定义信号处理函数，如：fun

回调函数的定义如下：

void fun(int signo)

{

// signo 为触发的信号，为 signal() 第一个参数的值

}

注意：信号处理函数应该为可重入函数，关于可重入函数的更多详情，请《浅谈可重入函数与不可重入函数》。

返回值：

成功：第一次返回 NULL，下一次返回此信号上一次注册的信号处理函数的地址。如果需要使用此返回值，必须在前面先声明此函数指针的类型。

失败：返回 SIG_ERR

示例一：

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <signal.h>  
3. #include <unistd.h>  
4.   
5. // 信号处理函数  
6. void signal_handler(int signo)  
7. {  
8.     if(signo == SIGINT){  
9.         printf("recv SIGINT\n");  
10.     }else if(signo == SIGQUIT){  
11.         printf("recv SIGQUIT\n");  
12.     }  
13. }  
14.   
15. int main(int argc, char *argv[])  
16. {  
17.     printf("wait for SIGINT OR SIGQUIT\n");  
18.       
19.     /* SIGINT: Ctrl+c ; SIGQUIT: Ctrl+\ */  
20.     // 信号注册函数  
21.     signal(SIGINT, signal_handler);  
22.     signal(SIGQUIT, signal_handler);  
23.       
24.     // 等待信号  
25.     pause();  
26.     pause();  
27.       
28.     return 0;  
29. }  

在终端里敲“Ctrl+c”或“Ctrl+\”，自动调用其指定好的回调函数 signal_handler():

示例二：

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <signal.h>  
3. #include <unistd.h>  
4.   
5. // 回调函数的声明  
6. typedef void (*sighandler_t)(int);  
7.   
8. void fun1(int signo)  
9. {  
10.     printf("in fun1\n");  
11. }  
12.   
13. void fun2(int signo)  
14. {  
15.     printf("in fun2\n");  
16. }  
17.   
18. int main(int argc, char *argv[])  
19. {  
20.     sighandler_t previous = NULL;  
21.       
22.     // 第一次返回 NULL  
23.     previous = signal(SIGINT,fun1);   
24.     if(previous == NULL)  
25.     {  
26.         printf("return fun addr is NULL\n");  
27.     }  
28.       
29.     // 下一次返回此信号上一次注册的信号处理函数的地址。  
30.     previous = signal(SIGINT, fun2);  
31.     if(previous == fun1)  
32.     {  
33.         printf("return fun addr is fun1\n");  
34.     }  
35.       
36.     // 还是返回 NULL，因为处理的信号变了  
37.     previous = signal(SIGQUIT,fun1);  
38.     if(previous == NULL)  
39.     {  
40.         printf("return fun addr is NULL\n");  
41.     }  
42.       
43.     return 0;  
44. }  

运行结果如下：

信号集与信号阻塞集

信号集

为了方便对多个信号进行处理，一个用户进程常常需要对多个信号做出处理，在 Linux 系统中引入了信号集（信号的集合）。这个信号集有点类似于我们的 QQ 群，一个个的信号相当于 QQ 群里的一个个好友。

信号集是用来表示多个信号的数据类型（sigset_t），其定义路径为：/usr/include/i386-linux-gnu/bits/sigset.h。

信号集相关的操作主要有如下几个函数：

[cpp] view plain copy

1. #include <signal.h>  
2. int sigemptyset(sigset_t *set);  
3. int sigfillset(sigset_t *set);  
4. int sigismember(const sigset_t *set, int signum);  
5. int sigaddset(sigset_t *set, int signum);  
6. int sigdelset(sigset_t *set, int signum);  

以上几个函数的用法都是比较简单，这里就不一一介绍，我们通过一个例子来学习其用法：

[cpp] view plain copy1

1. #include <signal.h>  
2. #include <stdio.h>  
3.   
4. int main(int argc, char *argv[])  
5. {  
6.     sigset_t set;   // 定义一个信号集变量  
7.     int ret = 0;  
8.   
9.     sigemptyset(&set); // 清空信号集的内容  
10.       
11.     // 判断 SIGINT 是否在信号集 set 里  
12.     // 在返回 1， 不在返回 0  
13.     ret = sigismember(&set, SIGINT);  
14.     if(ret == 0){  
15.         printf("SIGINT is not a member of set \nret = %d\n", ret);  
16.     }  
17.           
18.     sigaddset(&set, SIGINT); // 把 SIGINT 添加到信号集 set  
19.     sigaddset(&set, SIGQUIT);// 把 SIGQUIT 添加到信号集 set  
20.       
21.     // 判断 SIGINT 是否在信号集 set 里  
22.     // 在返回 1， 不在返回 0  
23.     ret = sigismember(&set, SIGINT);  
24.     if(ret == 1){  
25.         printf("SIGINT is a member of set \nret = %d\n", ret);  
26.     }  
27.       
28.     sigdelset(&set, SIGQUIT); // 把 SIGQUIT 从信号集 set 移除  
29.       
30.     // 判断 SIGQUIT 是否在信号集 set 里  
31.     // 在返回 1， 不在返回 0  
32.     ret = sigismember(&set, SIGQUIT);  
33.     if(ret == 0){  
34.         printf("SIGQUIT is not a member of set \nret = %d\n", ret);  
35.     }  
36.       
37.     return 0;  
38. }  

运行结果如下：

信号阻塞集(屏蔽集、掩码)

信号阻塞集也称信号屏蔽集、信号掩码。每个进程都有一个阻塞集，创建子进程时子进程将继承父进程的阻塞集。信号阻塞集用来描述哪些信号递送到该进程的时候被阻塞（在信号发生时记住它，直到进程准备好时再将信号通知进程）。

所谓阻塞并不是禁止传送信号, 而是暂缓信号的传送。若将被阻塞的信号从信号阻塞集中删除，且对应的信号在被阻塞时发生了，进程将会收到相应的信号。

我们可以通过 sigprocmask() 修改当前的信号掩码来改变信号的阻塞情况。

所需头文件：

#include <signal.h>

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

功能：

检查或修改信号阻塞集，根据 how 指定的方法对进程的阻塞集合进行修改，新的信号阻塞集由 set 指定，而原先的信号阻塞集合由 oldset 保存。

参数：

how: 信号阻塞集合的修改方法，有 3 种情况：

SIG_BLOCK：向信号阻塞集合中添加 set 信号集，新的信号掩码是set和旧信号掩码的并集。
SIG_UNBLOCK：从信号阻塞集合中删除 set 信号集，从当前信号掩码中去除 set 中的信号。
SIG_SETMASK：将信号阻塞集合设为 set 信号集，相当于原来信号阻塞集的内容清空，然后按照 set 中的信号重新设置信号阻塞集。

set: 要操作的信号集地址。

若 set 为 NULL，则不改变信号阻塞集合，函数只把当前信号阻塞集合保存到 oldset 中。

oldset: 保存原先信号阻塞集地址

返回值：

成功：0，

失败：-1，失败时错误代码只可能是 EINVAL，表示参数 how 不合法。

注意：不能阻塞 SIGKILL 和 SIGSTOP 等信号，但是当 set 参数包含这些信号时 sigprocmask() 不返回错误，只是忽略它们。另外，阻塞 SIGFPE 这样的信号可能导致不可挽回的结果，因为这些信号是由程序错误产生的，忽略它们只能导致程序无法执行而被终止。

示例代码如下：

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <unistd.h>  
4. #include <signal.h>  
5.   
6. int main(int argc, char *argv[])  
7. {  
8.     sigset_t set; // 信号集合  
9.     int i = 0;  
10.       
11.     sigemptyset(&set); // 清空信号集合  
12.     sigaddset(&set, SIGINT); // SIGINT 加入 set 集合  
13.       
14.     while(1)  
15.     {  
16.         // set 集合加入阻塞集，在没有移除前，SIGINT 会被阻塞  
17.         sigprocmask(SIG_BLOCK, &set, NULL);  
18.         for(i=0; i<5; i++)  
19.         {  
20.             printf("SIGINT signal is blocked\n");  
21.             sleep(1);  
22.         }  
23.           
24.         // set 集合从阻塞集中移除  
25.         // 假如 SIGINT 信号在被阻塞时发生了  
26.         // 此刻，SIGINT 信号立马生效，中断当前进程  
27.         sigprocmask(SIG_UNBLOCK, &set, NULL);  
28.         for(i=0; i<5; i++)  
29.         {  
30.             printf("SIGINT signal unblocked\n");  
31.             sleep(1);  
32.         }  
33.     }  
34.       
35.     return 0;  
36. }  

可靠信号的操作

从 UNIX 系统继承过来的信号（SIGHUP～SIGSYS，前 32 个）都是不可靠信号，不支持排队（多次发送相同的信号, 进程可能只能收到一次，可能会丢失）。

SIGRTMIN 至 SIGRTMAX 的信号支持排队（发多少次, 就可以收到多少次, 不会丢失），故称为可靠信号。

可靠信号就是实时信号，非可靠信号就是非实时信号。

signal() 函数只能提供简单的信号安装操作，使用 signal() 函数处理信号比较简单，只要把要处理的信号和处理函数列出即可。

signal() 函数主要用于前面 32 种不可靠、非实时信号的处理，并且不支持信号传递信息。

Linux 提供了功能更强大的 sigaction() 函数，此函数可以用来检查和更改信号处理操作，可以支持可靠、实时信号的处理，并且支持信号传递信息。

下面我们一起学习其相关函数的使用。

所需头文件：

#include <signal.h>

int sigqueue(pid_t pid, int sig, const union sigval value);

功能：

给指定进程发送信号。

参数：

pid: 进程号。

sig: 信号的编号，这里可以填数字编号，也可以填信号的宏定义，可以通过命令 kill -l ("l" 为字母)进行相应查看。

value: 通过信号传递的参数。

union sigval 类型如下：

[cpp] view plain copy

1. union sigval  
2. {  
3.     int   sival_int;  
4.     void *sival_ptr;  
5. };  

返回值：

成功：0

失败：-1

int sigaction(int signum,const struct sigaction *act, struct sigaction *oldact );

功能：

检查或修改指定信号的设置（或同时执行这两种操作）。

参数：

signum：要操作的信号。

act：   要设置的对信号的新处理方式（设置）。

oldact：原来对信号的处理方式（设置）。

如果 act 指针非空，则要改变指定信号的处理方式（设置），如果 oldact 指针非空，则系统将此前指定信号的处理方式（设置）存入 oldact。

返回值：

成功：0

失败：-1

信号设置结构体：

[cpp] view plain copy

1. struct sigaction  
2. {  
3.     /*旧的信号处理函数指针*/  
4.     void (*sa_handler)(int signum) ;  
5.       
6.     /*新的信号处理函数指针*/  
7.     void (*sa_sigaction)(int signum, siginfo_t *info, void *context);  
8.       
9.     sigset_t sa_mask;/*信号阻塞集*/  
10.       
11.     int sa_flags;/*信号处理的方式*/  
12. };  

sa_handler、sa_sigaction：信号处理函数指针，和 signal() 里的函数指针用法一样，应根据情况给 sa_sigaction、sa_handler 两者之一赋值，其取值如下：

SIG_IGN：忽略该信号

SIG_DFL：执行系统默认动作

处理函数名：自定义信号处理函数

sa_mask：信号阻塞集

sa_flags：用于指定信号处理的行为，它可以是一下值的“按位或”组合：

SA_RESTART：使被信号打断的系统调用自动重新发起（已经废弃）

SA_NOCLDSTOP：使父进程在它的子进程暂停或继续运行时不会收到 SIGCHLD 信号。

SA_NOCLDWAIT：使父进程在它的子进程退出时不会收到 SIGCHLD 信号，这时子进程如果退出也不会成为僵尸进程。

SA_NODEFER：使对信号的屏蔽无效，即在信号处理函数执行期间仍能发出这个信号。

SA_RESETHAND：信号处理之后重新设置为默认的处理方式。

SA_SIGINFO：使用 sa_sigaction 成员而不是 sa_handler 作为信号处理函数。

信号处理函数：
void (*sa_sigaction)( int signum,  siginfo_t *info,  void *context );
参数说明：

signum：信号的编号。
info：记录信号发送进程信息的结构体，进程信息结构体路径：/usr/include/i386-linux-gnu/bits/siginfo.h，其结构体详情请点此链接。
context：可以赋给指向 ucontext_t 类型的一个对象的指针，以引用在传递信号时被中断的接收进程或线程的上下文，其结构体详情点此链接。

下面我们做这么一个例子，一个进程在发送信号，一个进程在接收信号的发送。

发送信号示例代码如下：

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <signal.h>  
3. #include <sys/types.h>  
4. #include <unistd.h>  
5.   
6. /******************************************************* 
7. *功能：     发 SIGINT 信号及信号携带的值给指定的进程 
8. *参数：        argv[1]：进程号 
9.             argv[2]：待发送的值（默认为100） 
10. *返回值：   0 
11. ********************************************************/  
12. int main(int argc, char *argv[])  
13. {  
14.     if(argc >= 2)  
15.     {  
16.         pid_t pid,pid_self;  
17.         union sigval tmp;  
18.   
19.         pid = atoi(argv[1]); // 进程号  
20.         if( argc >= 3 )  
21.         {  
22.             tmp.sival_int = atoi(argv[2]);  
23.         }  
24.         else  
25.         {  
26.             tmp.sival_int = 100;  
27.         }  
28.           
29.         // 给进程 pid，发送 SIGINT 信号，并把 tmp 传递过去  
30.         sigqueue(pid, SIGINT, tmp);  
31.           
32.         pid_self = getpid(); // 进程号  
33.         printf("pid = %d, pid_self = %d\n", pid, pid_self);  
34.           
35.     }  
36.       
37.     return 0;  
38. }  

接收信号示例代码如下： [cpp] view plain copy

1. #include <signal.h>  
2. #include <stdio.h>  
3.   
4. // 信号处理回电函数  
5. void signal_handler(int signum, siginfo_t *info, void *ptr)  
6. {  
7.     printf("signum = %d\n", signum); // 信号编号  
8.     printf("info->si_pid = %d\n", info->si_pid); // 对方的进程号  
9.     printf("info->si_sigval = %d\n", info->si_value.sival_int); // 对方传递过来的信息  
10. }  
11.   
12. int main(int argc, char *argv[])  
13. {  
14.     struct sigaction act, oact;  
15.       
16.     act.sa_sigaction = signal_handler; //指定信号处理回调函数  
17.     sigemptyset(&act.sa_mask); // 阻塞集为空  
18.     act.sa_flags = SA_SIGINFO; // 指定调用 signal_handler  
19.       
20.     // 注册信号 SIGINT  
21.     sigaction(SIGINT, &act, &oact);  
22.       
23.     while(1)  
24.     {  
25.         printf("pid is %d\n", getpid()); // 进程号  
26.           
27.         pause(); // 捕获信号，此函数会阻塞  
28.     }  
29.       
30.     return 0;  
31. }  

两个终端分别编译代码，一个进程接收，一个进程发送，运行结果如下：

本教程示例代码下载请点此处。