信号是Linux所使用的进程间通信的最古老的方式。它是在软件层次上对中断机制的一种模拟，是一种异步通信的方式 。一个完整的信号周期包括三个部分，信号的产生，信号在进程中的注册，信号在进程中的注销，执行信号处理函数。如下图所示：

Linux 信号和信号集_linux

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

对信号的响应由三种方式：

1、忽略信号，即对信号不做任何的处理。除SIGKILL和SIGSTOP除外。

2、捕捉该信号，定义信号处理函数，当信号发生时，执行信号处理函数。

3、执行缺省操作，linux对每种信号都有默认的操作。

信号的发送通过kill函数和raise函数，两者的区别在于raise函数可以向本进程发送信号。

Linux 信号和信号集_include_02

Linux 信号和信号集_include_03


下面的代码展示了如何使用两个函数：

在实例中首先fork了一个子进程，为了保证子进程不在父进程调用kill函数之前退出，使用raise函数向子进程发送SINSTOP函数，将子进程暂停。接下来再在父进程中执行kill函数。

[cpp] view plain copy

  1. #include <stdio.h>  

  2. #include <stdlib.h>  

  3. #include <signal.h>  

  4. #include <sys/types.h>  

  5. #include <sys/wait.h>  

  6.   

  7. int main()  

  8. {  

  9.     pid_t pid;  

  10.     int ret;  

  11.     if((pid=fork())<0){  

  12.         perror("fork");  

  13.         exit(1);  

  14.     }  

  15.     if(pid == 0){  

  16.         raise(SIGSTOP);  

  17.         exit(0);  

  18.     }  

  19.     else{  

  20.         printf("pid=%d\n",pid);  

  21.         if((waitpid(pid,NULL,WNOHANG))==0){  

  22.             if((ret=kill(pid,SIGKILL))==0)  

  23.                 printf("kill %d\n",pid);  

  24.             else{  

  25.                 perror("kill");  

  26.             }  

  27.         }  

  28.     }  

  29. }  

程序执行的结果：


Linux 信号和信号集_linux_04


信号处理的方法有两种，一种是使用signal函数进行处理，另一种使用信号集函数。

signal函数：

使用signal函数时只需将处理的信号和处理的函数列出即可。

Linux 信号和信号集_linux_05


下面使用代码展示如何使用signal函数：

[cpp] view plain copy

  1. #include<stdio.h>  

  2. #include<stdlib.h>  

  3. #include<signal.h>  

  4. static void sig_usr(int signo);  

  5. int main(void)  

  6. {  

  7.     if(signal(SIGUSR1,sig_usr) == SIG_ERR)  

  8.         printf("Can't catch SIGUSR1");  

  9.           

  10.         if(signal(SIGUSR2,sig_usr) == SIG_ERR)  

  11.         printf("Can't catch SIGUSR2");  

  12.           

  13.         for(;;)  

  14.         pause();  

  15.           

  16.   

  17. }  

  18.   

  19. static void sig_usr(int signo)  

  20. {  

  21.     if(signo == SIGUSR1)  

  22.         printf("recevied SIGUSR1\n");  

  23.         else if (signo == SIGUSR2)  

  24.             printf("received SIGUSR2\n");  

  25.             else  

  26.             printf("received signal %d\n",signo);  

  27.           

  28.   

  29. }  


执行程序在后台运行：./signal &


Linux 信号和信号集_include_06

第二种是信号集处理信号：

信号集是一个能表示多个信号的数据类型，sigset_t set ；set即一个信号集。
　　既然是一个集合，就需要对集合进行添加/删除等操作。
　　int sigemptyset(sigset_t *set); 将set集合置空
　　int sigfillset(sigset_t *set)； 将所有信号加入set集合
　　int sigaddset(sigset_t *set,int signo); 将signo信号加入到set集合
　　int sigdelset(sigset_t *set，int signo); 从set集合中移除signo信号
　　int sigismember(const sigset_t *set,int signo); signo判断信号是否存在于set集合中


信号处理的过程如下：


Linux 信号和信号集_linux_07

Linux 信号和信号集_include_08Linux 信号和信号集_linux_09

struct sigaction {
　　void (*sa_handler)();/*处理函数或SIG_IGN(忽略)或SIG_DFL(默认)*/
　　sigset_t sa_mask; /*处理函数过程中被阻塞*/
　　int sa_flags; /*标志位，对信号进程处理选项*/
　　} ;



[cpp] view plain copy

  1. <span style="font-size:18px">#include <sys/types.h>  

  2. #include <unistd.h>  

  3. #include <signal.h>  

  4. #include <stdio.h>  

  5. #include <stdlib.h>  

  6. //自定义信号处理函数  

  7. void my_func(int signum)  

  8. {  

  9.     printf("If you want to quit,please try SIGQUIT\n");  

  10. }  

  11. int main()  

  12. {  

  13.     sigset_t set,pendset;  

  14.     struct sigaction action1,action2;  

  15.     //初始化信号集为空  

  16.     if(sigemptyset(&set)<0)  

  17.         perror("sigemptyset");  

  18.         //将相应的信号加入信号集  

  19.     if(sigaddset(&set,SIGQUIT)<0)  

  20.         perror("sigaddset");  

  21.     if(sigaddset(&set,SIGINT)<0)  

  22.         perror("sigaddset");  

  23.         //设置信号集屏蔽字  

  24.     if(sigprocmask(SIG_BLOCK,&set,NULL)<0)  

  25.         perror("sigprocmask");  

  26.     else  

  27.     {  

  28.         printf("blocked\n");  

  29.         sleep(5);  

  30.     }  

  31.     if(sigprocmask(SIG_UNBLOCK,&set,NULL)<0)  

  32.         perror("sigprocmask");  

  33.     else  

  34.         printf("unblock\n");  

  35.           

  36.         //对相应的信号进行屏蔽处理  

  37.     while(1){  

  38.         if(sigismember(&set,SIGINT)){  

  39.             sigemptyset(&action1.sa_mask);  

  40.             action1.sa_handler=my_func;  

  41.             sigaction(SIGINT,&action1,NULL);  

  42.         }else if(sigismember(&set,SIGQUIT)){  

  43.             sigemptyset(&action2.sa_mask);  

  44.             action2.sa_handler = SIG_DFL;  

  45.             sigaction(SIGTERM,&action2,NULL);  

  46.         }  

  47.     }  

  48. }  

  49. </span>  

打开两个终端，在一个终端中执行该程序，在另一个终端中发送信号。


发送信号：kill -SIGINT 进程号

kill  -SIGQUIT 进程号

程序运行的结果：

Linux 信号和信号集_include_10