Linux：信号（1）：signal函数、pause函数、alarm函数

╰半橙微兮° 2022-05-25 05:42 342阅读 0赞

想要有顺序地学习Linux，入口在这里哦：[Linux：目录索引][Linux]

*  一、信号
    
     *  1.什么是信号？
     *  2.哪些情况下会产生信号？
     *  3.如何查看信号？
     *  4.常用信号解释
     *  5.处理的三种方式
 *  二、操作信号
    
     *  1.注册信号
        
         *  ①作用
         *  ②注册信号所使用的函数signal()
         *  ③实例验证
         *  ④另一个可以获取信号的函数pause()
     *  2.给进程发送信号
        
         *  ①命令方式
         *  ②函数方式
         *  ③实例验证
         *  ④补充另外两个可以发送消息的函数
 *  三、SIGALRM信号
    
     *  1.alarm函数
     *  2.实例验证
     *  3.alarm的超时处理：简单的考试计时程序
     *  4.alarm的定时处理
        
         *  ①用于定时的函数：setitimer()
         *  ②对struct itimerval \*new\_value的详解
         *  ③定时处理的实例：

# 一、信号 #

## 1.什么是信号？ ##

> **系统为了响应某些状况而产生的事件**。进程收到信号后采取相应的动作。

## 2.哪些情况下会产生信号？ ##

> ①键盘事件，如：ctl c 、ctl \\  
> ②访问非法内存  
> ③硬件出现故障  
> ④用户态到内核态的切换

## 3.如何查看信号？ ##

> 指令：`kill -l` 查看系统所有信号  
> ![这里写图片描述][70]

## 4.常用信号解释 ##

<table> 
 <thead> 
  <tr> 
   <th>SIGINT</th> 
   <th>SIGQUIT</th> 
   <th>SIGUSER1</th> 
   <th>SIGALRM</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ctl c发出的信号</td> 
   <td>ctl \发出的信号</td> 
   <td>用户自定义信号，常用于发送和获取</td> 
   <td>闹钟信号，用于倒计时</td> 
  </tr> 
 </tbody> 
</table>

## 5.处理的三种方式 ##

> 当进程接收到信号时，有三种方式处理该信号  
> ①**忽略**：收到信号后，不处理  
> SIGKILL和SIGSTOP是不可能被忽略的  
> ②**捕获并处理**：收到信号后，执行我们自己写的代码  
> SIGKILL和SIGSTOP不能捕获  
> ③**默认处理方式**

# 二、操作信号 #

## 1.注册信号 ##

### ①作用 ###

> 注册信号实际是对信号进行三种处理操作，**用于告诉当前进程接收信号后该去执行什么动作**

### ②注册信号所使用的函数signal() ###

> 1.函数原型：  
> `typedef void (*sighandler_t)(int); sighandler_t signal(int signum, sighandler_t handler);`  
> 2.函数功能解释：  
> **开始获取信号值为signum的信号，如果获取到该信号，则开始执行handler指向的函数**  
> 3.返回值：  
> 成功返回原本的信号处理函数指针，失败返回 SIGERR，  
> SIGERR的宏为 \#define SIG\_IGN ((sighandler\_t)-1)  
> 4.参数解释  
> `signum`：指明了所要处理的信号类型，它可以取除了SIGKILL和SIGSTOP外的任何一种信号。  
> `handler`：用户自定义的函数；第二个参数不仅可以传函数指针handler，它还可以取以下三种值，如下表：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>SIG_IGN</th> 
   <th>SIG_DFL</th> 
   <th>handler</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>解释</td> 
   <td>忽略</td> 
   <td>默认处理</td> 
   <td>类型的函数指针</td> 
  </tr> 
  <tr> 
   <td>实质</td> 
   <td>#define SIG_IGN ((sighandler_t)1)</td> 
   <td>#define SIG_IGN ((sighandler_t)0)</td> 
   <td>执行自己写的代码</td> 
  </tr> 
 </tbody> 
</table>

### ③实例验证 ###

//验证SIG_IGN
    #include<stdio.h>
    #include<unistd.h>
    #include<signal.h>
    #include<stdlib.h>
    int main()
    {
        int i=0;
        signal(SIGINT,SIG_IGN);//SIGINT是ctl c发起的信号
        //SIG_IGN表示忽略接收到的信号
    
        for(i=0;i<10;++i)//执行10秒
        {
            printf("死不了:%d\n",i);
            sleep(1);
        }
        return 0;
    }

![这里写图片描述][70 1]

//验证SIG_DFL
    #include<stdio.h>
    #include<unistd.h>
    #include<signal.h>
    #include<stdlib.h>
    int main()
    {
        int i=0;
        signal(SIGINT,SIG_DFL);//SIGINT是ctl c发起的信号
        //SIG_DFL表示采用默认处理方式处理接收到的信号
        //把这句代码去掉，执行效果一样
    
        for(i=0;i<10;++i)//执行10秒
        {
            printf("死不了:%d\n",i);
            sleep(1);
        }
        return 0;
    }

![这里写图片描述][70 2]

//验证sighandler_t
    #include<stdio.h>
    #include<unistd.h>
    #include<signal.h>
    #include<stdlib.h>
    void handler(int n)//自定义的函数
    {
        printf("死掉了\n");
        exit(1);
    }
    
    int main()
    {
        signal(SIGINT,handler);//SIGINT是ctl c发起的信号
        while(1)
        {
            printf("死不了\n");
            sleep(1);
        }
        return 0;
    }

![这里写图片描述][70 3]

### ④另一个可以获取信号的函数pause() ###

> 1.函数原型：  
> `int pause(void);`  
> 2.功能解释：  
> **暂停进程，把当前进程置成就绪态，让出CPU，直到收到`任意一个`信号后终止，并且当处理完该信号之后，直接执行pause()函数下面的语句**  
> 3.返回值：  
> 只返回-1  
> 4.参数解释：  
> 不需要传参，如：`pause();printf("pause over\n");`//当前进程暂停，直到系统任意发出一个信号，pause()才被终止（打断），开始继续执行printf()。

## 2.给进程发送信号 ##

### ①命令方式 ###

> 指令：`kill -信号值 pid`

### ②函数方式 ###

> 1.函数原型：  
> `int kill(int pid,int signum);`  
> 2.函数功能解释：  
> **给进程id为pid的进程发送一个信号值为signum的信号**  
> 3.返回值：  
> 成功返回0，失败返回-1  
> 4.参数解释  
> `signum`：信号值，即信号编号  
> `pid`：进程id，它可以取以下四种值，如下表：

<table> 
 <thead> 
  <tr> 
   <th>pid &gt; 0</th> 
   <th>pid = 0</th> 
   <th>pid = -1</th> 
   <th>pid &lt; -1</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>将信号发送给pid对应的进程</td> 
   <td>将信号发送给调用者所在<strong>进程组</strong>的所有进程</td> 
   <td>将信号发送给所有进程（1号进程除外）</td> 
   <td>将信号发送给<strong>进程组</strong> id 为|pid|的进程组中所有进程</td> 
  </tr> 
 </tbody> 
</table>

> 补充：`进程组`：如管道连接的进程、fork创建的父子进程

### ③实例验证 ###

#include<stdio.h>
    #include<unistd.h>
    #include<signal.h>
    #include<stdlib.h>
    
    void handler(int n)//自定义函数，用于验证能接收到信号
    {
        printf("我收到信号了\n");
    }
    
    int main()
    {
        int i=0;
        signal(SIGUSR1,handler);//父进程在获取信号SIGUSR1
        //SIGUSER1：用户自定义信号，常用于发送和接收
        pid_t pid=fork();
        if(pid == 0)//子进程
        {
            sleep(1);
            kill(getppid(),SIGUSR1);//将信号SIGUSER1发送给父进程
            exit(0);
        }
        else
        {
            while(1)
            {
                printf("滴滴\n");
                sleep(3);
            }
        }
        return 0;
    }

![这里写图片描述][70 4]

### ④补充另外两个可以发送消息的函数 ###

> 1.`int rasie (int signum);` 给自己发送信号  
> 返回值：成功返回0；失败：返回-1  
> 2.`int killpg(int gid,int signum);` 给进程组发送信号  
> 返回值：-1，并把error值设为EINTR

# 三、SIGALRM信号 #

## 1.alarm函数 ##

> ①函数原型：  
> `unsigned int alarm(unsigned int seconds);`  
> ②函数功能解释：  
> **若干秒后，给当前进程发送一个SIGALRM信号**  
> ③返回值：  
> 成功：如果调用此alarm（）前，进程已经设置了闹钟时间，则返回上一个闹钟时间的剩余时间，否则返回0。  
> 失败：-1  
> ④参数解释  
> `second > 0`：当seconds秒后，触发SIGALRM信号  
> `seconds = 0`： 表示清除SIGALRM信号

## 2.实例验证 ##

#include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <signal.h>
    
    void handler(int s) {
        printf("超时\n");
        exit(1);
    }
    
    int main( void )
    {
        char buf[100] = {
        };
        printf("输入名字:");
    
        signal(SIGALRM, handler);//捕获到SIGALRM信号后执行handler函数
    
        alarm(3);//设置倒计时为3
        //如果3秒结束没有清除SIGALRM信号，则获取SIGALRM信号
        scanf("%s", buf);
        alarm(0); //清楚SIGALRM信号
    
        printf("名字为：%s\n", buf);
    
        for ( ; ; ) //用于验证alarm(0)确实清除了SIGALRM信号
        {
            printf("滴滴\n");
            sleep(1);
        }
    }

![这里写图片描述][70 5]

## 3.alarm的超时处理：简单的考试计时程序 ##

#include <stdio.h>
    #include <stdlib.h>
    #include <signal.h>
    #include <unistd.h>
    
    int Right = 0;//做对的题数
    int Wrong = 0;//做错的题数
    
    void handler(int s) //用于验证超时
    {
        printf("时间到\n");
        printf("Right=%d, Wrong=%d\n", Right, Wrong);
        exit(1);
    }
    
    int main( void )
    {
        int i=0;
        signal(SIGALRM, handler);//获取SIGALRM信号，执行handler函数
    
        alarm(20);//设置倒计时为20
        srand(getpid());//随机数种子
        for (i=0; i<10; i++) //出10道10以内的加法题
        {
            int left = rand()%10;
            int right = rand()%10;
            printf("%d+%d=", left, right);
            int ret;
            scanf("%d", &ret);
            if ( left + right == ret ) 
            {
                Right++;
            } 
            else
             {
                Wrong++;
            }
        }
        printf("做完了\n");
        printf("Right=%d, Wrong=%d\n", Right, Wrong);
    }

![这里写图片描述][70 6]

## 4.alarm的定时处理 ##

### ①用于定时的函数：setitimer() ###

> 1.函数原型：  
> `#include <sys/time.h> int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);`  
> 2.函数功能解释：  
> **设置一个定时器，从第n秒（n是自己设定）开始启动定时器，然后每隔m秒（m也是自己设定）发出一个SIGALRM信号**  
> 3.返回值：  
> 返回-1表示失败，0表示成功  
> 4.参数解释  
> `which`：一般写成`ITIMER_REAL`，即真实的桌面时间  
> `new_value`：一个结构体指针，结构体内部存储着“启动时间”和“间隔时间”，具体的在下面有详解  
> `old_value`：同样的结构体指针，一般写成`NULL`

### ②对struct itimerval \*new\_value的详解 ###

> 1.结构体内部的信息  
> `struct itimerval { struct timeval it_interval; /*以后每一次执行的间隔时间*/ struct timeval it_value; /*第一次执行的时间*/ }; struct timeval //时间的精确度 { long tv_sec; /* 时间的秒部分*/ long tv_usec; /*时间的微秒部分*/ };`  
> 2.实例说明该结构体的作用  
> `struct itimerval it; //上句代码的作用是定义一个该结构体变量it，it包括两部分信息：启动时间和间隔时间 it.it_value.tv_sec = 0; it.it_value.tv_usec = 1; //上两句代码的作用是将it的启动时间设为：真实的桌面时间+0秒1微秒 it.it_interval.tv_sec = 1; it.it_interval.tv_usec = 0; //上两句代码的作用是将it的间隔时间设为：1秒0微妙`

### ③定时处理的实例： ###

#include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <signal.h>
    #include <sys/time.h>
    
    void handler(int s)
    {
        printf("收到SIGALRM信号了\n");
    }
    
    int main( void )
    {
        signal(SIGALRM, handler);//如果获取到SIGALRM信号，则执行handler函数
    
        struct itimerval it;
        //上句代码的作用是定义一个该结构体变量it，it包括两部分信息：启动时间和间隔时间
        it.it_value.tv_sec     = 0; 
        it.it_value.tv_usec    = 1;
        //上两句代码的作用是将it的启动时间设为：真实的桌面时间+0秒1微秒
        it.it_interval.tv_sec  = 1;
        it.it_interval.tv_usec = 0;
        //上两句代码的作用是将it的间隔时间设为：1秒0微妙
    
        setitimer(ITIMER_REAL, &it, NULL);
        //上面的定时器内部信息设置完后，通过setitimer函数启动该定时器
    
        while(1)//无限循环，用于验证定时器确实是每个一段时间就发出一个SIGALRM信号
            ;
    
    }

![这里写图片描述][70 7]

[Linux]: https://blog.csdn.net/w_y_x_y/article/details/80017600
[70]: /images/20220525/fe75cf2b75ac4da0bffbd2082e62eb27.png
[70 1]: /images/20220525/ab8a130d02dc42758deea1550c88b141.png
[70 2]: /images/20220525/4d1ce9b7831d41888f4ddd586adb4036.png
[70 3]: /images/20220525/2bbcb2fecf084806a3e20b2769a7e683.png
[70 4]: /images/20220525/85baa5dfcb6044749bceba7d03fd3ca7.png
[70 5]: /images/20220525/9ef98f6fcbc44a969ffa5e4c2c6e55ee.png
[70 6]: /images/20220525/0972d15009c94a12803cb5b9032f7a26.png
[70 7]: /images/20220525/60ee90d8e8c746bcaa77b9215a12e7c4.png