接上文

5. 信号的发送

发送信号的主要函数有：kill()、raise()、 sigqueue()、alarm()、setitimer()以及abort()。

5.1 kill()

1. #include <sys/types.h> 
2. #include <signal.h> 
3. int kill(pid_t pid,int signo)  

该系统调用可以用来向任何进程或进程组发送任何信号。参数pid的值为信号的接收进程

pid>0 进程ID为pid的进程

pid=0 同一个进程组的进程

pid<0 pid!=-1 进程组ID为 -pid的所有进程

pid=-1 除发送进程自身外，所有进程ID大于1的进程

Sinno是信号值，当为0时(即空信号)，实际不发送任何信号，但照常进行错误检查，因此，可用于检查目标进程是否存在，以及当前进程是否具有向目标发送信号的权限(root权限的进程可以向任何进程发送信号，非root权限的进程只能向属于同一个session或者同一个用户的进程发送信号)。

Kill()最常用于pid>0时的信号发送。该调用执行成功时，返回值为0;错误时，返回-1，并设置相应的错误代码errno。下面是一些可能返回的错误代码：

EINVAL：指定的信号sig无效。

ESRCH：参数pid指定的进程或进程组不存在。注意，在进程表项中存在的进程，可能是一个还没有被wait收回，但已经终止执行的僵死进程。

EPERM： 进程没有权力将这个信号发送到指定接收信号的进程。因为，一个进程被允许将信号发送到进程pid时，必须拥有root权力，或者是发出调用的进程的UID 或EUID与指定接收的进程的UID或保存用户ID(savedset-user-ID)相同。如果参数pid小于-1，即该信号发送给一个组，则该错误表示组中有成员进程不能接收该信号。

5.2 sigqueue()

1. #include <sys/types.h> 
2. #include <signal.h> 
3. int sigqueue(pid_t pid, int sig, const union sigval val)  

调用成功返回 0;否则，返回 -1。

sigqueue()是比较新的发送信号系统调用，主要是针对实时信号提出的(当然也支持前32种)，支持信号带有参数，与函数sigaction()配合使用。

sigqueue的第一个参数是指定接收信号的进程ID，第二个参数确定即将发送的信号，第三个参数是一个联合数据结构union sigval，指定了信号传递的参数，即通常所说的4字节值。

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

sigqueue()比kill()传递了更多的附加信息，但sigqueue()只能向一个进程发送信号，而不能发送信号给一个进程组。如果signo=0，将会执行错误检查，但实际上不发送任何信号，0值信号可用于检查pid的有效性以及当前进程是否有权限向目标进程发送信号。

在调用sigqueue时，sigval_t指定的信息会拷贝到对应sig 注册的3参数信号处理函数的siginfo_t结构中，这样信号处理函数就可以处理这些信息了。由于sigqueue系统调用支持发送带参数信号，所以比kill()系统调用的功能要灵活和强大得多。

5.3 alarm()

1. #include <unistd.h> 
2.  
3. unsigned int alarm(unsigned int seconds)  

系统调用alarm安排内核为调用进程在指定的seconds秒后发出一个SIGALRM的信号。如果指定的参数seconds为0，则不再发送 SIGALRM信号。后一次设定将取消前一次的设定。该调用返回值为上次定时调用到发送之间剩余的时间，或者因为没有前一次定时调用而返回0。

注意，在使用时，alarm只设定为发送一次信号，如果要多次发送，就要多次使用alarm调用。

5.4 setitimer()

现在的系统中很多程序不再使用alarm调用，而是使用setitimer调用来设置定时器，用getitimer来得到定时器的状态，这两个调用的声明格式如下：

1. int getitimer(int which, struct itimerval *value); 
2. int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue);  

在使用这两个调用的进程中加入以下头文件：

1. #include <sys/time.h> 

该系统调用给进程提供了三个定时器，它们各自有其独有的计时域，当其中任何一个到达，就发送一个相应的信号给进程，并使得计时器重新开始。三个计时器由参数which指定，如下所示：

TIMER_REAL：按实际时间计时，计时到达将给进程发送SIGALRM信号。

ITIMER_VIRTUAL：仅当进程执行时才进行计时。计时到达将发送SIGVTALRM信号给进程。

ITIMER_PROF：当进程执行时和系统为该进程执行动作时都计时。与ITIMER_VIR-TUAL是一对，该定时器经常用来统计进程在用户态和内核态花费的时间。计时到达将发送SIGPROF信号给进程。

定时器中的参数value用来指明定时器的时间，其结构如下：

1. struct itimerval { 
2. struct timeval it_interval; /* 下一次的取值 */ 
3. struct timeval it_value; /* 本次的设定值 */ 
4. };  

该结构中timeval结构定义如下：

1. struct timeval { 
2. long tv_sec; /* 秒 */ 
3. long tv_usec; /* 微秒，1秒 = 1000000 微秒*/ 
4. };  

在setitimer 调用中，参数ovalue如果不为空，则其中保留的是上次调用设定的值。定时器将it_value递减到0时，产生一个信号，并将it_value的值设定为it_interval的值，然后重新开始计时，如此往复。当it_value设定为0时，计时器停止，或者当它计时到期，而it_interval 为0时停止。调用成功时，返回0;错误时，返回-1，并设置相应的错误代码errno：

EFAULT：参数value或ovalue是无效的指针。

EINVAL：参数which不是ITIMER_REAL、ITIMER_VIRT或ITIMER_PROF中的一个。

下面是关于setitimer调用的一个简单示范，在该例子中，每隔一秒发出一个SIGALRM，每隔0.5秒发出一个SIGVTALRM信号：

1. #include <signal.h> 
2.  
3. #include <unistd.h> 
4.  
5. #include <stdio.h> 
6.  
7. #include <sys/time.h> 
8.  
9. int sec; 
10.  
11.   
12.  
13. void sigroutine(int signo) { 
14.  
15.         switch (signo) { 
16.  
17.         case SIGALRM: 
18.  
19.         printf("Catch a signal -- SIGALRM "); 
20.  
21.         break; 
22.  
23.         case SIGVTALRM: 
24.  
25.         printf("Catch a signal -- SIGVTALRM "); 
26.  
27.         break; 
28.  
29.         } 
30.  
31.         return; 
32.  
33. } 
34.  
35.   
36.  
37. int main() 
38.  
39. { 
40.  
41.         struct itimerval value,ovalue,value2; 
42.  
43.         sec = 5; 
44.  
45.   
46.  
47.         printf("process id is %d ",getpid()); 
48.  
49.         signal(SIGALRM, sigroutine); 
50.  
51.         signal(SIGVTALRM, sigroutine); 
52.  
53.   
54.  
55.         value.it_value.tv_sec = 1; 
56.  
57.         value.it_value.tv_usec = 0; 
58.  
59.         value.it_interval.tv_sec = 1; 
60.  
61.         value.it_interval.tv_usec = 0; 
62.  
63.         setitimer(ITIMER_REAL, &value, &ovalue); 
64.  
65.   
66.  
67.         value2.it_value.tv_sec = 0; 
68.  
69.         value2.it_value.tv_usec = 500000; 
70.  
71.         value2.it_interval.tv_sec = 0; 
72.  
73.         value2.it_interval.tv_usec = 500000; 
74.  
75.         setitimer(ITIMER_VIRTUAL, &value2, &ovalue); 
76.  
77.   
78.  
79.         for (;;) ; 
80.  
81. }  

该例子的屏幕拷贝如下：

1. localhost:~$ ./timer_test 
2.  
3. process id is 579 
4.  
5. Catch a signal – SIGVTALRM 
6.  
7. Catch a signal – SIGALRM 
8.  
9. Catch a signal – SIGVTALRM 
10.  
11. Catch a signal – SIGVTALRM 
12.  
13. Catch a signal – SIGALRM 
14.  
15. Catch a signal –GVTALRM  

5.5 abort()

1. #include <stdlib.h> 
2.  
3. void abort(void);  

向进程发送SIGABORT信号，默认情况下进程会异常退出，当然可定义自己的信号处理函数。即使SIGABORT被进程设置为阻塞信号，调用abort()后，SIGABORT仍然能被进程接收。该函数无返回值。

5.6 raise()

1. #include <signal.h> 
2. int raise(int signo)  

向进程本身发送信号，参数为即将发送的信号值。调用成功返回 0;否则，返回 -1。

6. 信号集及信号集操作函数：

信号集被定义为一种数据类型：

1. typedef struct { 
2. unsigned long sig[_NSIG_WORDS]; 
3. } sigset_t  

信号集用来描述信号的集合，每个信号占用一位。Linux所支持的所有信号可以全部或部分的出现在信号集中，主要与信号阻塞相关函数配合使用。下面是为信号集操作定义的相关函数：

1. #include <signal.h> 
2. int sigemptyset(sigset_t *set)； 
3. int sigfillset(sigset_t *set)； 
4. int sigaddset(sigset_t *set, int signum)； 
5. int sigdelset(sigset_t *set, int signum)； 
6. int sigismember(const sigset_t *set, int signum)； 
7. sigemptyset(sigset_t *set)初始化由set指定的信号集，信号集里面的所有信号被清空； 
8. sigfillset(sigset_t *set)调用该函数后，set指向的信号集中将包含linux支持的64种信号； 
9. sigaddset(sigset_t *set, int signum)在set指向的信号集中加入signum信号； 
10. sigdelset(sigset_t *set, int signum)在set指向的信号集中删除signum信号； 
11. sigismember(const sigset_t *set, int signum)判定信号signum是否在set指向的信号集中。  

7. 信号阻塞与信号未决:

每个进程都有一个用来描述哪些信号递送到进程时将被阻塞的信号集，该信号集中的所有信号在递送到进程后都将被阻塞。下面是与信号阻塞相关的几个函数：

1. #include <signal.h> 
2. int  sigprocmask(int  how,  const  sigset_t *set, sigset_t *oldset))； 
3. int sigpending(sigset_t *set)); 
4. int sigsuspend(const sigset_t *mask))；  

sigprocmask()函数能够根据参数how来实现对信号集的操作，操作主要有三种：

SIG_BLOCK 在进程当前阻塞信号集中添加set指向信号集中的信号

SIG_UNBLOCK 如果进程阻塞信号集中包含set指向信号集中的信号，则解除对该信号的阻塞

SIG_SETMASK 更新进程阻塞信号集为set指向的信号集

sigpending(sigset_t *set))获得当前已递送到进程，却被阻塞的所有信号，在set指向的信号集中返回结果。

sigsuspend(const sigset_t *mask))用于在接收到某个信号之前, 临时用mask替换进程的信号掩码, 并暂停进程执行，直到收到信号为止。sigsuspend 返回后将恢复调用之前的信号掩码。信号处理函数完成后，进程将继续执行。该系统调用始终返回-1，并将errno设置为EINTR。

8. 信号应用实例

linux下的信号应用并没有想象的那么恐怖，程序员所要做的最多只有三件事情：

1. 安装信号(推荐使用sigaction());
2. 实现三参数信号处理函数，handler(int signal,struct siginfo *info, void *);
3. 发送信号，推荐使用sigqueue()。

实际上，对有些信号来说，只要安装信号就足够了(信号处理方式采用缺省或忽略)。其他可能要做的无非是与信号集相关的几种操作。

实例一：信号发送及处理

实现一个信号接收程序sigreceive(其中信号安装由sigaction())。

1. #include <signal.h> 
2.  
3. #include <sys/types.h> 
4.  
5. #include <unistd.h> 
6.  
7. void new_op(int,siginfo_t*,void*); 
8.  
9. int main(int argc,char**argv) 
10.  
11. { 
12.  
13.         struct sigaction act;   
14.  
15.         int sig; 
16.  
17.         sig=atoi(argv[1]); 
18.  
19.         
20.  
21.         sigemptyset(&act.sa_mask); 
22.  
23.         act.sa_flags=SA_SIGINFO; 
24.  
25.         act.sa_sigaction=new_op; 
26.  
27.         
28.  
29.         if(sigaction(sig,&act,NULL) < 0) 
30.  
31.         { 
32.  
33.                 printf("install sigal error\n"); 
34.  
35.         } 
36.  
37.         
38.  
39.         while(1) 
40.  
41.         { 
42.  
43.                 sleep(2); 
44.  
45.                 printf("wait for the signal\n"); 
46.  
47.         } 
48.  
49. } 
50.  
51.   
52.  
53. void new_op(int signum,siginfo_t *info,void *myact) 
54.  
55. { 
56.  
57.         printf("receive signal %d", signum); 
58.  
59.         sleep(5); 
60.  
61. }  

说明，命令行参数为信号值，后台运行sigreceive signo &，可获得该进程的ID，假设为pid，然后再另一终端上运行kill -s signo pid验证信号的发送接收及处理。同时，可验证信号的排队问题。

实例二：信号传递附加信息

主要包括两个实例：

向进程本身发送信号，并传递指针参数

1. #include <signal.h> 
2.  
3. #include <sys/types.h> 
4.  
5. #include <unistd.h> 
6.  
7. void new_op(int,siginfo_t*,void*); 
8.  
9. int main(int argc,char**argv) 
10.  
11. { 
12.  
13.         struct sigaction act;   
14.  
15.         union sigval mysigval; 
16.  
17.         int i; 
18.  
19.         int sig; 
20.  
21.         pid_t pid;          
22.  
23.         char data[10]; 
24.  
25.         memset(data,0,sizeof(data)); 
26.  
27.         for(i=0;i < 5;i++) 
28.  
29.                 data[i]='2'; 
30.  
31.         mysigval.sival_ptr=data; 
32.  
33.         
34.  
35.         sig=atoi(argv[1]); 
36.  
37.         pid=getpid(); 
38.  
39.         
40.  
41.         sigemptyset(&act.sa_mask); 
42.  
43.         act.sa_sigaction=new_op;//三参数信号处理函数 
44.  
45.         act.sa_flags=SA_SIGINFO;//信息传递开关，允许传说参数信息给new_op 
46.  
47.         if(sigaction(sig,&act,NULL) < 0) 
48.  
49.         { 
50.  
51.                 printf("install sigal error\n"); 
52.  
53.         } 
54.  
55.         while(1) 
56.  
57.         { 
58.  
59.                 sleep(2); 
60.  
61.                 printf("wait for the signal\n"); 
62.  
63.                 sigqueue(pid,sig,mysigval);//向本进程发送信号，并传递附加信息 
64.  
65.         } 
66.  
67. } 
68.  
69. void new_op(int signum,siginfo_t *info,void *myact)//三参数信号处理函数的实现 
70.  
71. { 
72.  
73.         int i; 
74.  
75.         for(i=0;i<10;i++) 
76.  
77.         { 
78.  
79.                 printf("%c\n ",(*( (char*)((*info).si_ptr)+i))); 
80.  
81.         } 
82.  
83.         printf("handle signal %d over;",signum); 
84.  
85. }  

这个例子中，信号实现了附加信息的传递，信号究竟如何对这些信息进行处理则取决于具体的应用。

不同进程间传递整型参数：

把1中的信号发送和接收放在两个程序中，并且在发送过程中传递整型参数。

信号接收程序：

1. #include <signal.h> 
2.  
3. #include <sys/types.h> 
4.  
5. #include <unistd.h> 
6.  
7. void new_op(int,siginfo_t*,void*); 
8.  
9. int main(int argc,char**argv) 
10.  
11. { 
12.  
13.         struct sigaction act; 
14.  
15.         int sig; 
16.  
17.         pid_t pid;          
18.  
19.         
20.  
21.         pid=getpid(); 
22.  
23.         sig=atoi(argv[1]);      
24.  
25.         
26.  
27.         sigemptyset(&act.sa_mask); 
28.  
29.         act.sa_sigaction=new_op; 
30.  
31.         act.sa_flags=SA_SIGINFO; 
32.  
33.         if(sigaction(sig,&act,NULL)<0) 
34.  
35.         { 
36.  
37.                 printf("install sigal error\n"); 
38.  
39.         } 
40.  
41.         while(1) 
42.  
43.         { 
44.  
45.                 sleep(2); 
46.  
47.                 printf("wait for the signal\n"); 
48.  
49.         } 
50.  
51. } 
52.  
53. void new_op(int signum,siginfo_t *info,void *myact) 
54.  
55. { 
56.  
57.         printf("the int value is %d \n",info->si_int); 
58.  
59. } 
60.  
61.    

信号发送程序：

命令行第二个参数为信号值，第三个参数为接收进程ID。

1. #include <signal.h> 
2.  
3. #include <sys/time.h> 
4.  
5. #include <unistd.h> 
6.  
7. #include <sys/types.h> 
8.  
9. main(int argc,char**argv) 
10.  
11. { 
12.  
13.         pid_t pid; 
14.  
15.         int signum; 
16.  
17.         union sigval mysigval; 
18.  
19.         signum=atoi(argv[1]); 
20.  
21.         pid=(pid_t)atoi(argv[2]); 
22.  
23.         mysigval.sival_int=8;//不代表具体含义，只用于说明问题 
24.  
25.         if(sigqueue(pid,signum,mysigval)==-1) 
26.  
27.                 printf("send error\n"); 
28.  
29.         sleep(2); 
30.  
31. }  

注：实例2的两个例子侧重点在于用信号来传递信息，目前关于在linux下通过信号传递信息的实例非常少，倒是Unix下有一些，但传递的基本上都是关于传递一个整数

实例三：信号阻塞及信号集操作

1. #include "signal.h" 
2.  
3. #include "unistd.h" 
4.  
5. static void my_op(int); 
6.  
7. main() 
8.  
9. { 
10.  
11.         sigset_t new_mask,old_mask,pending_mask; 
12.  
13.         struct sigaction act; 
14.  
15.         sigemptyset(&act.sa_mask); 
16.  
17.         act.sa_flags=SA_SIGINFO; 
18.  
19.         act.sa_sigaction=(void*)my_op; 
20.  
21.         if(sigaction(SIGRTMIN+10,&act,NULL)) 
22.  
23.                 printf("install signal SIGRTMIN+10 error\n"); 
24.  
25.         sigemptyset(&new_mask); 
26.  
27.         sigaddset(&new_mask,SIGRTMIN+10); 
28.  
29.         if(sigprocmask(SIG_BLOCK, &new_mask,&old_mask)) 
30.  
31.                 printf("block signal SIGRTMIN+10 error\n"); 
32.  
33.         sleep(10); 
34.  
35.         printf("now begin to get pending mask and unblock SIGRTMIN+10\n"); 
36.  
37.         if(sigpending(&pending_mask)<0) 
38.  
39.                 printf("get pending mask error\n"); 
40.  
41.         if(sigismember(&pending_mask,SIGRTMIN+10)) 
42.  
43.                 printf("signal SIGRTMIN+10 is pending\n"); 
44.  
45.         if(sigprocmask(SIG_SETMASK,&old_mask,NULL)<0) 
46.  
47.                 printf("unblock signal error\n"); 
48.  
49.         printf("signal unblocked\n"); 
50.  
51.         sleep(10); 
52.  
53. } 
54.  
55.   
56.  
57. static void my_op(int signum) 
58.  
59. { 
60.  
61.         printf("receive signal %d \n",signum); 
62.  
63. }  

编译该程序，并以后台方式运行。在另一终端向该进程发送信号(运行kill -s 42 pid，SIGRTMIN+10为42)，查看结果可以看出几个关键函数的运行机制，信号集相关操作比较简单。

本文作者：佚名

来源：51CTO