2.2 linux中的信号分析

信号：

　　信号是UNIX系统响应某些状况而产生的事件，进程在接收到信号时会采取相应的行动。

　　信号是因为某些错误条件而产生的，比如内存段冲突、浮点处理器错误或者非法指令等。

　　信号是在软件层次上对中断的一种模拟，所以通常把它称为是软中断。

　　信号和中断的区别：　　

　　　　相似点：

　　　　　　采用了相同的异步通信方式。

　　　　　　当检测出有信号或者中断请求时，都暂停正在执行的程序而转去执行相应的处理程序。

　　　　　　都在处理完毕后返回到原来的断点。

　　　　　　对信号和中断都可以进行屏蔽。

　　　　区别：

　　　　　　中断有优先级，而信号没有优先级，所有的信号都是平等的。

　　　　　　信号处理程序都是在用户态下运行的，而中断处理程序是在核心态下运行。

　　　　　　中断响应是及时的，而信号响应通常都有较大的延迟。

　　常用的信号如下所示：

进程对信号的三种响应如下：

man 7 signal可以查看信号的默认动作和信号的含义。

　　signal用于安装一个信号处理函数，原型如下：

　　__sighandler_t  signal(int signum, __sighandler_t  handler)

　　signal是一个带signum和handler两个参数的函数，准备捕捉或者屏蔽的信号由参数signum给出，接收到指定信号时将要调用的函数由handler给出。

　　handler这个函数必须有一个int型参数（即接收到的信号代码），它本身的类型是void。

　　handler也可以是下面两个特殊值：

　　　　SIG_IGN  忽略该信号

　　　　SIG_DFL  恢复默认行为

示例程序如下：

 #include <stdio.h>
 #include <stdlib.h>
 #include <signal.h>

 void handler(int num)
 {
     printf("recv signal num = %d\n", num);
 }

 int main()
 {
     pid_t pid;

     signal(SIGCHLD, SIG_IGN);

     pid = fork();

     if(pid == -)
     {
         perror("fork error");
         exit();
     }

     if(pid == )
     {
         printf("child ... \n");
         exit();
     }
     while()
     {
         pause();
     }

     return ;
 }

程序中，我们注册信号时，表示父进程忽略子进程的退出信号，因此，执行结果如下：

默认情况下（当我们不使用signal信号时），父进程会在退出的时候给子进程收尸（前提是子进程先死），可用如下程序证明：

 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <signal.h>

 void handler(int num)
 {
     printf("recv signal num = %d\n", num);
 }

 int main()
 {
     pid_t pid;

     //signal(SIGCHLD, SIG_IGN);

     pid = fork();

     if(pid == -)
     {
         perror("fork error");
         exit();
     }

     if(pid == )
     {
         printf("child ... \n");
         exit();
     }

     sleep();
     //while(1)
     //{
     //    pause();
     //}

     return ;
 }

我们让父进程睡眠5秒，保证子进程先死，当父进程还在睡眠时，我们在另一个中断执行ps -ef，结果如下：

可以看到，父进程睡眠期间，子进程已经死了，而且处于僵尸状态，但是当父进程也结束时，子进程的僵尸状态消失了，说明父进程给它收尸了。当把17行的注释打开时，就是告诉内核，子进程死的时候让内核给他收尸，因此，我们看不到子进程处于僵尸状态的现象了（内核收尸太快了）。

　　下面我们演示注册一个真正的信号处理函数和恢复默认行为的程序：

 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <signal.h>

 void handler(int num)
 {
     printf("recv signal num = %d\n", num);
 }

 int main()
 {
     pid_t pid;
     char c;

     signal(SIGINT, handler);

     while( (c = getchar()) != 'a')
     {
         pause();
     }

     signal(SIGINT, SIG_DFL);
     while()
     {
         pause();
     }

     return ;
 }

SIGINT代表ctrl+c信号，18行将这个信号的处理函数注册为handler，当程序停在20行时，我们按下ctrl+c，handler会得到执行。 输入a使程序执行到26行，这时候SIGINT信号的行为恢复到了默认行为（25行中的SIG_DFL表示恢复默认行为），我们再按下ctrl+c，程序直接退出了（这就是默认行为）。执行现象如下：

　　signal函数执行成功时，返回默认的处理函数，执行失败时返回SIG_ERR。我们将上述程序改成以下方式：

 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <signal.h>

 void handler(int num)
 {
     printf("recv signal num = %d\n", num);
 }

 int main()
 {
     pid_t pid;
     char c;

     __sighandler_t old = signal(SIGINT, handler);

     if(SIG_ERR == old)
     {
         perror("signal error");
     }

     while( (c = getchar()) != 'a')
     {
         pause();
     }

     signal(SIGINT, old);
     printf("huan yuan\n");
     while()
     {
         pause();
     }

     return ;
 }

使用signal注册信号处理函数时，将默认的处理函数返回到old中，并在下面进行了错误处理，28行恢复默认行为，执行结果如下：

信号的分类：可靠与不可靠信号，实时与非实时信号。实时信号都是可靠信号，非实时信号都是不可靠信号。1-31号都是不可靠信号。不可靠信号就是向应用程序发送了多次信号，应用程序可能只接收到了一次。可靠信号就是向应用程序发几次信号都能保证全接收到。早期unix系统每接收到一个信号就将处理程序恢复到默认行为。现在的linux中的不可靠信号主要指信号可能会丢失。

信号发送函数kill和raise，如下所示：

kill可以向指定进程发送信号，raise向自身发送信号。 kill是示例程序如下：

 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <signal.h>

 void my_handler(int num)
 {
     if(SIGINT == num)
     {
         printf("recv signal SIGINT\n");
     }
     else if(SIGUSR1 == num)
     {
         printf("recv signal SIGUSR1\n");
     }
     else
     {
         printf("recv signal num = %d\n", num);
     }
 }

 int main()
 {
     pid_t pid;

     if(signal(SIGINT, my_handler) == SIG_ERR)
     {
         perror("signal error");
     }

     if(signal(SIGUSR1, my_handler) == SIG_ERR)
     {
         perror("signal error");
     }

     pid = fork();

     if(pid == -)
     {
         perror("fork error");
         exit();
     }

     if(pid == )
     {
         pid = getppid();
         kill(pid, SIGUSR1);
         exit();
     }

     int nsleep = ;

     do
     {
         printf("parent process begin sleep\n");
         nsleep = sleep(nsleep);
         printf("parent process end sleep\n");
     }while(nsleep > );

     return ;
 }

子进程通过kill向父进程发信号，父进程在睡眠，当收到信号时就去执行信号处理函数，执行完之后，发现nsleep不为0，也即没有睡够指定的时间，因此再次进入睡眠，直到睡完为止。执行结果如下：

小知识：

　　getpgrp()获取进程组id， kill(pid, SIGINT)向进程组发送SIGINT。父进程注册的信号处理函数也会复制给子进程（在fork之前注册信号）。sleep函数返回值是剩余的秒数。sleep能被信号打断，是可中断睡眠，处理信号函数返回以后就不再睡眠了，继续向下执行。wait使进程进入的睡眠也是可中断睡眠。

pause函数：

　　将进程置为可中断睡眠状态，然后它调用内核函数schedule()，使linux进程调度器找到另一个进程来运行。

　　pause使调用者进程挂起，直到一个信号被捕获。

alarm函数：

　　设置一个闹钟，延迟发送信号，告诉linux内核n秒钟以后，给本进程发送SIGALRM信号。示例程序如下：

 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <signal.h>

 void my_handler(int num)
 {
     printf("recv signal num = %d\n", num);
 }

 int main()
 {
     if(signal(SIGALRM, my_handler) == SIG_ERR)
     {
         perror("signal error");
         exit();
     }

     alarm();

     pause();
     printf("return from pause  \n");

     return ;
 }

执行结果如下所示：

可重入与不可重入：

示例程序如下：

 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <signal.h>

 typedef struct _Teacher
 {
     int age;
     int num;
 }Teacher;

 Teacher g_t;

 void printGlobalTeacher()
 {
     printf("g_t.age = %d\n", g_t.age);
     printf("g_t.num = %d\n", g_t.num);
 }

 void my_handler(int num)
 {
     printf("recv signal num = %d\n", num);
     printGlobalTeacher();
     alarm();
 }

 int main()
 {
     Teacher t1,t2;
     t1.age = ;
     t1.num = ;
     t2.age = ;
     t2.num = ;

     if(signal(SIGALRM, my_handler) == SIG_ERR)
     {
         perror("signal error");
         exit();
     }

     alarm();

     while()
     {
         g_t = t1;
         g_t = t2;
         //printf("return from pause  \n");
     }
     return ;
 }

上述程序中在信号处理函数中调用printGlobalTeacher函数，这个函数是不可重入的函数，因为函数内部访问了全局变量g_t， 因此打印结果有可能出错。执行结果如下：

可以看到出现了age和num不相等的情况，这就是出错了。