实验七 信号

这个作业属于哪个课程	链接
这个作业的要求在哪里	链接
学号-姓名	17041426-张洋安
作业学习目标	1、了解信号的概念 2、掌握信号处理的方法

1. 编写一个简单的程序并运行，然后向该进程发送不同的信号以观察该进程对接收到信号的反应。

   #include
   #include
   int main(){
     printf("hello signal! I'm %d\n",getpid());
     while(1){
       write(STDOUT_FILENO, ".",1);
       sleep(10);
   }
     return 0;
   }
   

   

   （1）我们可以在当前终端通过按键组合向该进程发送信号 CTRL+C 、 CTRL+Z 、 CTRL+\ 。

   按下CTRL+C

按下CTRL+Z

按下CTRL+\

（2）另外再开启一个终端，在终端通过输入 kill 命令来给进程发送信号，进程的 pid 在程序运行的第一 行输出

我们可以在终端通过输入 kill -l 来查看当前系统当中的信号列表:

重新运行hellosignal在当前终端我们可以看到程序输出自己的 pid 是3994,这是我们可以另开一个终端,通过 kill 命令向该 进程发送信号，再切换到运行程序的终端来观察进程接收到信号后的反应

（3）我们编写一个简单的程序，该程序调用 kill（）函数向某个进程发送信号

#include
#include
#include
#include
int main(int argc, char *argv[]){
  if(argc < 2)
  {
    printf("%s arg error.",argv[0]);
    exit(1);
  }
  kill(atoi(argv[1]),SIGKILL);
  return 0;
}

我们继续运行之前的程序等待有信号到来，在另外一个终端完成上面程序的输入并编译，运行的时候把4501作为参数，再返回之前运行 hellosignal 的终端观察进程接收到信号的反应：

2. 使用signal()函数来捕捉信号。

   通常进程在接收到某种信号后，会根据不同的信号执行默认的操作：忽略信号 、终止（杀死）进程 产生核心转储文件，同时 终止进程 、停止进程 、恢复之前被暂停的进程继续运行。这里我们可以 通过 signal（）来改变进程对某个信号的处置方式。

   #include  //catchsignal.c
   #include  
   #include  
   #include  
   #include  
   #include  
   void sighandler(int sig) {    
          switch(sig) {        
          case SIGUSR1://10            
              printf("hello SIGUSR1\n");break;       
          case SIGUSR2://12            
              printf("hello SIGUSR2\n");break;        
          case SIGINT://2 CTRL+C            
              printf("休想干掉我！\n");break;        
          case SIGTSTP://20 CTRL+Z            
              printf("不要停止我！\n");break;        
          case SIGQUIT://3 CTRL+\            
              printf("就是不退出！\n");break;        
          case SIGSEGV://11            
              printf("呃！程序出 bug 了！\n");break;        
          default:            
              printf("hello, who are you %d?\n", sig);    
          }    
          sleep(2); // 删除这一行，再给程序发信号，看看 main 函数打点的情况。 
   } 
   int main() {   
          printf("I'm %d\n", getpid());    
          if (SIG_ERR == signal(SIGUSR1, sighandler)) {        
              perror("signal SIGUSR1");    
          }    
          if (SIG_ERR == signal(SIGUSR2, sighandler)) {        
              perror("signal SIGUSR2");    
          }    
          if (SIG_ERR == signal(SIGINT, sighandler)) {        
              perror("signal SIGINT");    
          }    
          if (SIG_ERR == signal(SIGTSTP, sighandler)) {        
              perror("signal SIGTSTP");    }    
          if (SIG_ERR == signal(SIGQUIT, sighandler)) {        
              perror("signal SIGQUTI");
           }    
           if (SIG_ERR == signal(SIGSEGV, sighandler)) {       
              perror("signal SIGSEGV");    
           }    
           while(1) {        
              write(STDOUT_FILENO, ".", 1);         
              sleep(10);    
           }       
           return 0; 
   }
   

   我们输入完上述代码，编译并运行，然后再给该进程发送信号，观察进程对接收到信号的反应：

我们在另外一个终端输入 kill 命令来向该进程发送信号：

3. 通过举例说明alarm()函数和setitimer()函数的使用。

   一个非常简单的例子

   #include
   #include
   #include
    
   int main(){
   alarm(1);
   while(1);
   {
   printf("process will finish!\n");
   }
   return 0;
   }
   

   虽然程序中有无限循环，不断输出字符串 process will finish! ,由于调用了 alarm(1) 函数， alarm 函数会在1秒后给该进程发送 SIGALRM 信号，然后进程结束。

接下来继续看一个程序设定了两次定时炸弹，第一次设定 5 秒后爆炸，设定后过了 2 秒，再设定了一个 3 秒后爆炸的定时炸弹。

#include 
#include 
 #include  
void handler(int sig) {
if (sig == SIGALRM) printf("Bomb!!!!!!!!\n");
 }
int main() {
if(SIG_ERR == signal(SIGALRM, handler)) {
    perror("signal SIGALRM");
}
unsigned int remain = 0;
    remain = alarm(5); // 设定 5 秒后爆炸
    printf("the previous alarm remain %d seconds\n", remain);
    sleep(3); // 等待 3 秒 
remain = alarm(3); // 设定 3 秒后爆炸，同时会取消前面那个定时炸弹 
printf("the previous alarm remain %d seconds\n", remain);
    while(1) { 
write(STDOUT_FILENO, ".", 1);
    pause();
    } 
}

这里计时时间到了并不会结束进程，因为我们编写了信号捕捉函数，产生 SIGALRM 信号后会输出字符 串 Bomb!!!!!!!!

接下来我们用 setitimer() 函数实现 alarm() 函数

#include
#include
#include
#include
unsigned int my_alarm(unsigned int sec)
{
struct itimerval it,oldit;
int ret;
it.it_value.tv_sec=sec;
it.it_value.tv_usec=0;
it.it_interval.tv_sec=0;
it.it_interval.tv_usec=0;
ret = setitimer( ITIMER_REAL, &it, &oldit);
if(ret==-1)
{
perror("setitimer()");
exit(1) ;
}
return oldit.it_value.tv_sec;
}
int main(){
my_alarm( 1) ;
while(1)
{
printf( "process will finish! \n");
}
return 0;
}

程序在运行1秒钟后被 SIGALRM 信号结束。

大家可以分析一下 alarm() 函数和 setitimer() 函数的区别。

alarm函数
设置定时器（闹钟）。可代替alarm函数。精度微秒us。在指定seconds后，内核会给当前进程发送SIGALRM信号。进程收到该信号，默认动作终止。

setitimer函数
setitimer是一个比较常用的函数，可用来实现延时和定时的功能
使用时需要引入的头文件

include

4. 举例说明信号集操作函数的使用。

   编写一个打印 sigset_t 的函数

   void printsigset(const sigset_t *set)
    { 
   int i; 
   for (i = 1; i <= 64; i++) {
   if (i==33)
   putchar(' '); 
   if (sigismember(set, i) == 1)
   putchar('1');
   else
   putchar('0'); 
   }
   puts(""); 
   }
   

   #include  
   #include  
   #include  
   void printsigset(const sigset_t *set)
    { 
   int i; 
   for (i = 1; i <= 64; i++) {
   if (i==33)
   putchar(' '); 
   if (sigismember(set, i) == 1)
   putchar('1');
   else
   putchar('0'); 
   }
   puts(""); 
   }
   int main() { 
   sigset_t st; 
   printf("1. create set\n");
   printsigset(&st);
    
   printf("\n2. vertify sigset_t is a 64-bit integer\n");
   unsigned int test[2] = {0xf0f0f0f0, 0xf0f0f0f0}; 
   printsigset((sigset_t*)test); // 这种方法不被推荐，仅供测试用。 
   // fill set
   printf("\n3. fill set\n"); 
   sigfillset(&st); 
   printsigset(&st);
   // empty set printf("\n4. empty set\n"); 
   sigemptyset(&st); 
   printsigset(&st); // add sig 
   printf("\n5. add SIGHUP(1), SIGINT(2), SIGKILL(9), SIGSYS(31), SIGRTMIN(34) and SIGRTMAX(64) to set\n"); 
   sigaddset(&st, SIGHUP); 
   sigaddset(&st, SIGINT);
   sigaddset(&st, SIGKILL); 
   sigaddset(&st, SIGSYS);
   sigaddset(&st, SIGRTMIN); 
   sigaddset(&st, SIGRTMAX); 
   printsigset(&st); 
    
   // delete sig 
   printf("\n6. delete SIGKILL from set\n");
   sigdelset(&st, SIGKILL);
   printsigset(&st); 
    
   // is member 
   printf("\n"); 
   if (sigismember(&st, SIGKILL)) { 
   printf("SIGKILL is member\n");
   }
   if (sigismember(&st, SIGINT)) { 
   printf("SIGINT is member\n"); 
   }
   return 0; 
   }
   

   

5. 举例说明对阻塞信号与未决信号的理解。

   ​ 在一个进程中，保存了两个信号集（在PCB中），分别是阻塞信号集，还有一个未决信号集。当你使用 sigprocmask 的时候，就会修改阻塞信号集。
   ​ 当你的进程一收到信号且该信号被阻塞，它首先进入到未决信号集中（就是一个 sigset_t ），当未决 信号集中的信号被信号处理函数（你自己定义的或者系统默认的）处理，就会从未决信号集中删除。如果一个信号加入阻塞信号集，该信号的信号处理函数就不会被调用。

   #include  
   #include 
   #include  
   #include  
   void printsigset(const sigset_t *set)
    { 
   int i;
   for (i = 1; i <= 64; i++) {
   if (i==33) 
   putchar(' ');
   if (sigismember(set, i) == 1) 
   putchar('1'); 
   else
   putchar('0'); 
   }
   puts("");
    }
   void handler(int sig) { 
   if (sig == SIGINT) 
   printf("hello SIGINT\n");
   if (sig == SIGQUIT)
   printf("hello SIGQUIT\n");
    }
   int main() { 
   printf("I'm %d\n", getpid());
   sigset_t st, oldst; 
   sigemptyset(&st); 
   sigaddset(&st, SIGINT); 
   sigaddset(&st, SIGTSTP);
   sigprocmask(SIG_BLOCK, &st, &oldst); 
   printf("new set:"); 
   printsigset(&st);
   printf("old set:");
   printsigset(&oldst); 
    
   if (SIG_ERR == signal(SIGINT, handler)) {
   perror("signal SIGINT"); 
   return 1; 
   }
   if (SIG_ERR == signal(SIGQUIT, handler)) { 
   perror("signal SIGQUIT");
   return 1; 
   }
   puts("");
   int n = 0; 
   while(1) { 
   sigpending(&st); 
   printsigset(&st);
   puts("");
   sleep(1);
   if (n == 10) { 
   sigset_t tmp;
   sigemptyset(&tmp);
   sigaddset(&tmp, SIGINT); 
   sigprocmask(SIG_UNBLOCK, &tmp, NULL); 
   }   
   ++n; 
   }
   return 0; 
   }
   

   下面结合例子来理解，程序的功能是先把 SIGINT 、 SIGTSTP 加入到了进程阻塞信号集中去。接下

   来，每隔一秒打印一次未决信号集，第 10 次的时候，又把 SIGINT 信号从阻塞信号集中删除。

   

6. 举例说明sigaction()函数的使用。

   不同于 signal 函数， sigaction 函数是符合 POSIX 标准的，而 signal 只是 ANSI C 定义的函数。 除了上面的区别外， sigaction 提供了更多的功能。比如它可以处理带参数的信号，在信号处理的时 候，可以屏蔽其它信号等等。

#include  
#include 
 #include  
void printsigset(const sigset_t *set)
 { 
int i;
for (i = 1; i <= 64; i++) {
if (i==33) 
putchar(' ');
if (sigismember(set, i) == 1)
putchar('1');
else
putchar('0'); 
}
puts("");
 }
 
void handler(int sig) {
if (sig == SIGTSTP) 
printf("hello SIGTSTP\n"); 
if (sig == SIGINT) 
printf("hello SIGINT\n");
sleep(5); 
sigset_t st; 
sigpending(&st); 
printsigset(&st);
 }
int main() { 
printf("I'm %d\n", getpid());
struct sigaction act, oldact; act.sa_handler = handler; 
 

sigemptyset(&act.sa_mask); 
sigaddset(&act.sa_mask, SIGINT);
act.sa_flags = 0;  
 
sigaction(SIGTSTP, &act, &oldact); 
sigaction(SIGINT, &act, &oldact); 
 
while(1) {
write(STDOUT_FILENO, ".", 1); 
pause(); 
}
return 0;
}

给出一个程序来说明 sigaction() 函数的使用，程序注册了信号 SIGINT 和 SIGTSTP . 需要注意 的一点是 sa_mask 被设置为 SIGINT ，它表示当执行信号处理函数的时候，阻塞信 SIGINT 信号。我 在 handler 函数加入了一打印未决信号的功能，以验证执行到 handler 的时候发送 SIGINT 是被阻 塞住的。

1. 当程序运行的时候， Ctrl+C 进入 handler ，然后立即 Ctrl+Z 发现 handler 还未执行完就被 SIGTSTP 打断.
2. 当程序运行的时候， Ctrl+Z 进入 handler ，然后立即 Ctrl+C 发现并不会被 SIGINT 打断，这是因 为该 handler 注册的时候被设置了 SA_MASK = SIGINT 。最后 handler 结束的时候打印了未决信号 集，发现里头有 SIGINT 。所以 handler 结束后，又去继续对 SIGINT 进行处理。