信号机制是进程之间相互传递消息的一种方法，信号全称为软中断信号，也有人称作软中断。从它的命名可以看出，它的实质和使用很象中断。所以，信号可以说是进程控制的一部分。
一、信号的基本概念
1、基本概念
软中断信号（signal，又简称为信号）用来通知进程发生了异步事件。进程之间可以互相通过系统调用kill发送软中断信号。内核也可以因为内部事件而给进程发送信号，通知进程发生了某个事件。注意，信号只是用来通知某进程发生了什么事件，并不给该进程传递任何数据。
收 到信号的进程对各种信号有不同的处理方法。处理方法可以分为三类：第一种是类似中断的处理程序，对于需要处理的信号，进程可以指定处理函数，由该函数来处 理。第二种方法是，忽略某个信号，对该信号不做任何处理，就象未发生过一样。第三种方法是，对该信号的处理保留系统的默认值，这种缺省操作，对大部分的信 号的缺省操作是使得进程终止。进程通过系统调用signal来指定进程对某个信号的处理行为。
在进程表的表项中有一个软中断信号域，该域中每一位对应一个信号，当有信号发送给进程时，对应位置位。由此可以看出，进程对不同的信号可以同时保留，但对于同一个信号，进程并不知道在处理之前来过多少个。
2、信号的类型
发出信号的原因很多，这里按发出信号的原因简单分类，以了解各种信号：
（1） 与进程终止相关的信号。当进程退出，或者子进程终止时，发出这类信号。
（2） 与进程例外事件相关的信号。如进程越界，或企图写一个只读的内存区域（如程序正文区），或执行一个特权指令及其他各种硬件错误。
（3） 与在系统调用期间遇到不可恢复条件相关的信号。如执行系统调用exec时，原有资源已经释放，而目前系统资源又已经耗尽。
（4） 与执行系统调用时遇到非预测错误条件相关的信号。如执行一个并不存在的系统调用。
（5） 在用户态下的进程发出的信号。如进程调用系统调用kill向其他进程发送信号。
（6） 与终端交互相关的信号。如用户关闭一个终端，或按下break键等情况。
（7） 跟踪进程执行的信号。
值 名 字 说明
01 SIGHUP 挂起（hangup）
02 SIGINT 中断，当用户从键盘按ctrl+c键
03 SIGQUIT 退出，当用户从键盘按quit键时
04 SIGILL 非法指令
05 SIGTRAP 跟踪陷阱（trace trap），启动进程，跟踪代码的执行
06 SIGIOT IOT指令
07 SIGEMT EMT指令
08 SIGFPE 浮点运算溢出
09 SIGKILL 杀死、终止进程
10 SIGBUS 总线错误
11 SIGSEGV 段违例（segmentation? violation），进程试图去访问其虚地址空间以外的位置
12 SIGSYS 系统调用中参数错，如系统调用号非法
13 SIGPIPE 向某个非读管道中写入数据
14 SIGALRM 闹钟。当某进程希望在某时间后接收信号时发此信号
15 SIGTERM 软件终止（software? termination）
16 SIGUSR1 用户自定义信号1
17 SIGUSR2 用户自定义信号2
18 SIGCLD 某个子进程死
19 SIGPWR 电源故障
注意 信号SIGKILL和SIGSTOP既不能被捕捉，也不能被忽略。信号SIGIOT与SIGABRT是一个信号。可以看出，同一个信号在不同的系统中值可能不一样，所以建议最好使用为信号定义的名字，而不要直接使用信号的值。
二、有关信号的系统调用
系统调用signal是进程用来设定某个信号的处理方法，系统调用kill是用来发送信号给指定进程的。这 两个调用可以形成信号的基本操作。后两个调用pause和alarm是通过信号实现的进程暂停和定时器，调用alarm是通过信号通知进程定时器到时。所 以在这里，我们还要介绍这两个调用。
1、signal 系统调用
系统调用signal用来设定某个信号的处理方法。该调用声明的格式如下：
void (*signal(int signum, void
(*handler)(int)))(int);
在使用该调用的进程中加入以下头文件：
#include <signal.h>
上述声明格式比较复杂，如果不清楚如何使用，也可以通过下面这种类型定义的格式来使用（POSIX的定义）：
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum,
sighandler_t handler);
但这种格式在不同的系统中有不同的类型定义，所以要使用这种格式，最好还是参考一下联机手册。
在调用中，参数signum指出要设置处理方法的信号。第二个参数handler是一个处理函数，或者是
SIG_IGN：忽略参数signum所指的信号。
SIG_DFL：恢复参数signum所指信号的处理方法为默认值。
传递给信号处理例程的整数参数是信号值，这样可以使得一个信号处理例程处理多个信号。系统调用signal返回值是指定信号signum前一次的处理例程或者错误时返回错误代码SIG_ERR。下面来看一个简单的例子：
#include
<signal.h>
#include <unistd.h>
#include <stdio.h>
void sigroutine(int dunno) { /* 信号处理例程，其中dunno将会得到信号的值 */
switch (dunno) {
case 1:
printf("Get a signal -- SIGHUP
");
break;
case 2:
printf("Get a signal -- SIGINT
");
break;
case 3:
printf("Get a signal -- SIGQUIT
");
break;
}
return;
}
int main() {
printf("process id is %d
",getpid());
signal(SIGHUP, sigroutine); //* 下面设置三个信号的处理方法
signal(SIGINT, sigroutine);
signal(SIGQUIT, sigroutine);
for (;;) ;
}
其中信号SIGINT由按下Ctrl-C发出，信号SIGQUIT由按下Ctrl-发出。该程序执行的结果如下：
localhost:~$ ./sig_test
process id is 463
Get a signal -SIGINT //按下Ctrl-C得到的结果
Get a signal -SIGQUIT //按下Ctrl-得到的结果
//按下Ctrl-z将进程置于后台
[1]+ Stopped ./sig_test
localhost:~$ bg
[1]+ ./sig_test &
localhost:~$ kill -HUP 463 //向进程发送SIGHUP信号
localhost:~$ Get a signal – SIGHUP
kill -9 463 //向进程发送SIGKILL信号，终止进程
localhost:~$
2、kill 系统调用
系统调用kill用来向进程发送一个信号。该调用声明的格式如下：
int kill(pid_t pid, int sig);
在使用该调用的进程中加入以下头文件：
#include <sys/types.h>
#include <signal.h>
该 系统调用可以用来向任何进程或进程组发送任何信号。
如果参数pid是正数，那么该调用将信号sig发送到进程号为pid的进程。
如果pid等于0，那么信 号sig将发送给当前进程所属进程组里的所有进程。
如果参数pid等于-1，信号sig将发送给除了进程1和自身以外的所有进程。
如果参数pid小于- 1，信号sig将发送给属于进程组-pid的所有进程。如果参数sig为0，将不发送信号。该调用执行成功时，返回值为0；错误时，返回-1，并设置相应 的错误代码errno。下面是一些可能返回的错误代码：
EINVAL：指定的信号sig无效。
ESRCH：参数pid指定的进程或进程组不存在。注意，在进程表项中存在的进程，可能是一个还没有被wait收回，但已经终止执行的僵死进程。
EPERM： 进程没有权力将这个信号发送到指定接收信号的进程。因为，一个进程被允许将信号发送到进程pid时，必须拥有root权力，或者是发出调用的进程的UID 或EUID与指定接收的进程的UID或保存用户ID（savedset-user-ID）相同。如果参数pid小于-1，即该信号发送给一个组，则该错误 表示组中有成员进程不能接收该信号。
3、pause系统调用
系统调用pause的作用是等待一个信号。该调用的声明格式如下：
int pause(void);
在使用该调用的进程中加入以下头文件：
#include <unistd.h>
该调用使得发出调用的进程进入睡眠，直到接收到一个信号为止。该调用总是返回-1，并设置错误代码为EINTR（接收到一个信号）。下面是一个简单的范例：
#include
<unistd.h>
#include <stdio.h>
#include <signal.h>
void sigroutine(int unused) {
printf("Catch a signal SIGINT
");
}
int main() {
signal(SIGINT, sigroutine);
pause();
printf("receive a signal
");
}
在这个例子中，程序开始执行，就象进入了死循环一样，这是因为进程正在等待信号，当我们按下Ctrl-C时，信号被捕捉，并且使得pause退出等待状态。
4、alarm和 setitimer系统调用
系统调用alarm的功能是设置一个定时器，当定时器计时到达时，将发出一个信号给进程。该调用的声明格式如下：
unsigned int alarm(unsigned int
seconds);
在使用该调用的进程中加入以下头文件：
#include <unistd.h>
系 统调用alarm安排内核为调用进程在指定的seconds秒后发出一个SIGALRM的信号。如果指定的参数seconds为0，则不再发送 SIGALRM信号。后一次设定将取消前一次的设定。该调用返回值为上次定时调用到发送之间剩余的时间，或者因为没有前一次定时调用而返回0。
注意，在使用时，alarm只设定为发送一次信号，如果要多次发送，就要多次使用alarm调用。
对于alarm，这里不再举例。现在的系统中很多程序不再使用alarm调用，而是使用setitimer调用来设置定时器，用getitimer来得到定时器的状态，这两个调用的声明格式如下：
int getitimer(int which, struct
itimerval *value);
int setitimer(int which, const
struct itimerval *value, struct itimerval *ovalue);
在使用这两个调用的进程中加入以下头文件：
#include <sys/time.h>
该系统调用给进程提供了三个定时器，它们各自有其独有的计时域，当其中任何一个到达，就发送一个相应的信号给进程，并使得计时器重新开始。三个计时器由参数which指定，如下所示：
TIMER_REAL：按实际时间计时，计时到达将给进程发送SIGALRM信号。
ITIMER_VIRTUAL：仅当进程执行时才进行计时。计时到达将发送SIGVTALRM信号给进程。
ITIMER_PROF：当进程执行时和系统为该进程执行动作时都计时。与ITIMER_VIR-TUAL是一对，该定时器经常用来统计进程在用户态和内核态花费的时间。计时到达将发送SIGPROF信号给进程。
定时器中的参数value用来指明定时器的时间，其结构如下：
struct itimerval {
struct timeval it_interval; /* 下一次的取值 */
struct timeval it_value; /* 本次的设定值 */
};
该结构中timeval结构定义如下：
struct timeval {
long tv_sec; /* 秒 */
long tv_usec; /* 微秒，1秒 = 1000000 微秒*/
};
在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信号：
#include
<signal.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/time.h>
int sec;
void sigroutine(int
signo) {
switch (signo) {
case SIGALRM:
printf("Catch a signal --
SIGALRM ");
break;
case SIGVTALRM:
printf("Catch a signal --
SIGVTALRM ");
break;
}
return;
}
int main() {
struct itimerval
value,ovalue,value2;
sec = 5;
printf("process id
is %d ",getpid());
signal(SIGALRM, sigroutine);
signal(SIGVTALRM, sigroutine);
value.it_value.tv_sec =
1;
value.it_value.tv_usec = 0;
value.it_interval.tv_sec = 1;
value.it_interval.tv_usec = 0;
setitimer(ITIMER_REAL, &value,
&ovalue);
value2.it_value.tv_sec
= 0;
value2.it_value.tv_usec = 500000;
value2.it_interval.tv_sec = 0;
value2.it_interval.tv_usec = 500000;
setitimer(ITIMER_VIRTUAL,
&value2, &ovalue);
for (;;) ;
}
该例子的屏幕拷贝如下：
localhost:~$
./timer_test
process id is 579
Catch a signal – SIGVTALRM
Catch a signal – SIGALRM
Catch a signal – SIGVTALRM
Catch a signal – SIGVTALRM
Catch a signal – SIGALRM
Catch a signal –GVTALRM
三、参考代码
参考1.
#include<stdio.h>
char buf[]={"check lock! "};
main()
{
int i,p1,p2,fd;
fd=creat("lock.dat",0644);
write(fd,buf,20);
while((p1=fork())==-1);
if(p1==0)
{
lockf(fd,1,0);
for (i=1;i<=3;i++)
printf("child1! ");
lockf(fd,0,0);
}
else{while((p2=fork())==-1);
if (p2==0)
{
lockf(fd,1,0);
for (i=1;i<=4;i++)
printf("child2! ");
lockf(fd,0,0);
}
else printf("parrent! ");
}
close(fd);
}
参考 2
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
int waite;
static void start(){
waite=0;
}
//自定义中断调用函数
static void waiting(){
while(waite==1);
}
main(){
int pid1,pid2;
while((pid1=fork())==-1);
if(pid1>0){
printf("chilld process 1 is %d ",pid1);
while((pid2=fork())==-1);
if(pid2>0){
printf("child process 2 is %d ",pid2);
printf("please press 'delete' ");
waite=1;
if(signal(SIGUSR1,start)==SIG_ERR);
else{
alarm(5);
signal(SIGALRM,start);//alarm函数使用的信号
}
waiting();
kill(pid1,16);//向child 1 子进程发送16号中断
kill(pid2,17);//向child 2 子进程发送17号中断
wait(0);//等待两个子进程结束
wait(0);
printf("parent process is killed ");
exit(0);
}
else{
waite=1;
signal(17,start);//接受父进程发送的17号中断,调用信号中断函数start()
waiting();
printf("child 2 is killed ");
exit(0);
}
}
else{
waite=1;
signal(16,start);//接受父进程发送的16号中断,调用信号中断函数start()
waiting();
printf("child 1 is killed ");
exit(0);
}
}
参考三
#include <stdio.h>
#include <signal.h>
int main()
{
int i,j,stop();
signal(SIGINT,stop);
if(i=fork())
{
if(j=fork())
{
//signal(SIGINT,SIG_IGN);
sleep(10);
kill(i,15);
kill(j,16);
wait(0);
wait(0);
printf("Parent process is killed! ");
}
else {
signal(16,SIG_IGN);
sleep(10);
//signal(16,stop);
printf("Child process 3 is killed! ");
exit(0);
}
}
else {
signal(15,SIG_IGN);
sleep(10);
//signal(15,stop);
printf("Child process 1 is killed! ");
exit(0);
}
}
stop()
{
//printf("del key is got! ");
}
参考四
#include <stdio.h>
#include <unistd.h>
#include <stdio.h>
#include <signal.h>
int pid1,pid2;
main()
{
int fd[2];
char OutPipe[100],InPipe[100];
pipe(fd);
for(;;)
{
while((pid1=fork())==-1);
if(pid1 == 0)
{
lockf(fd[1],1,0);
sprintf(OutPipe,"Child process 1 is sending message! ");
write(fd[1],OutPipe,50);
sleep(3);
lockf(fd[1],0,0);
exit(0);
}
else {
while((pid2=fork())==-1);
if(pid2 == 0)
{
lockf(fd[1],1,0);
sprintf(OutPipe,"Child process 2 is sending message! ");
write(fd[1],OutPipe,50);
sleep(3);
lockf(fd[1],0,0);
}
else {
wait(0);
read(fd[0],InPipe,50);
printf("%s ",InPipe);
}
}
}
}