Unix高级编程：信号处理函数的注册、信号的产生、阻塞、未决

一、使用signal(2)向进程注册信号处理函数

"kill -l" 显示所有可用的系统信号的编号

/*举例向进程注册2号信号的用户自定义的处理程序，signal.c*/

#include <stdio.h>

#include <signal.h>

void handle(int signum) {

    printf("recv signal num %d..\n", signum);

    return;

}

int main(void) {

    #if 0 /* 想放开的时候，把 0 变成 1 */

    handle是signal回调函数的参数，在signal函数的实现中调用了handle函数，handle函数参数是信号的编号

    #endif

    signal(SIGINT, &handle);

    while(1);

    return 0;

}

补充：

1）注释补充

// C++的注释

/**/ C语言的注释，不能嵌套

#if 0

#endif 条件编译注释，0 换成 1 则让注释内容再次生效

2）信号场景的理解

1. 用户输入命令，在shell下启动一个前台进程

2. 用户按下Ctrl+C，这个键盘的输入产生一个硬件中断

3. 如果CPU当前正在执行这个进程的代码，则该进程的用户空间代码暂停执行，CPU"从用户态切换到内核态处理硬件中断"

4. 终端驱动程序将Ctrl+C解释成一个 SIGINT 信号，记录在该进程的PCB中

5. 当某个时刻，进程需要从内核态返回到用户态的时候，首先处理PCB中记录的信号，发现有一个SIGINT信号待处理，而这个信号的默认处理动作是终止该进程

6. 现场的情况：

————信号的处理函数是用户自定义的，调用用户自定义的信号处理函数，调用完毕，继续返回到内核态，该信号的记录清空，执行第 5 步。

二、信号的产生、闹钟与睡眠

第一种："硬件产生"，Ctrl+C 或者 Ctrl+\

第二种："使用命令产生" kill -信号编号 pid

第三种："使用函数产生" kill/raise/alarm等

"kill"(2)

#include <sys/types.h>

#include <signal.h>

int kill(pid_t pid, int sig);

功能：给一个进程发送信号（给进程号为pid的进程发送sig信号）

参数：

"pid" 进程pid号（>0 的情况）

"sig" 信号的编号

返回值：

成功 - 返回 0

失败 - 返回-1，errno被设置

/*举例验证，使用kill给某个进程发送信号，kill.c*/

#include <stdio.h>

#include <sys/types.h>

#include <signal.h>

#include <stdlib.h>

int main(int argc, char *argv[]) {

    pid_t pid;

    int signo;

    pid = atoi(argv[1]); //从命令行获取pid和signo

    signo = atoi(argv[2]);

    kill(pid, signo); //给指定的进程发送signo信号

    return 0;

}

"raise"(3)

#include <signal.h>

int raise(int sig);

功能：发送一个信号给自己的进程

参数："sig" 指定要发送给自己的信号编号

返回值：

成功 - 返回 0

失败 - 返回非 0

/*举例验证，给自己发送2号信号，signal3.c*/

#include <stdio.h>

#include <signal.h>

void handle(int signum) {

    printf("signal num %d..\n", signum);

    return;

}

int main(void) {

    int i = 0;

    signal(SIGINT, &handle);

    while(i++ < 5) {

        printf("i = %d\n", i); 

        if(i == 3) {

            raise(2); //i=1 i=2 i=3 signal num 2.. i=4 i=5

        }   

    }   

    return 0;

}

"alarm"(2) "闹钟"

#include <unistd.h>

unsigned int alarm(unsigned int seconds);

功能：整理一个信号在seconds指定的时间到达自己的进程

参数："seconds" 指定的时间，默认单位：秒
0 没有设置新闹钟

返回值：

成功 - 返回剩余的秒数，在闹钟时间到达的时候产生 14)SIGALRM 信号，发送给自己的进程

失败 - 返回 0 取消闹钟

/*举例验证alarm函数的使用，代码参见 alarm.c*/

#include <stdio.h>

#include <unistd.h>

int main(void) {

    int i = 0;

    alarm(1); //设置闹钟为1秒

    for(;; i++) {

        printf("i = %d\n", i);//可用来测试CPU的速度

    }   

    return 0;

}

"sleep"(3) "睡眠"

#include <unistd.h>

unsigned int sleep(unsigned int seconds);

功能：给程序指定seconds时间的睡眠

参数："seconds" 指定的时间，默认单位：秒

返回值：

成功 - 返回 0

失败 - 返回剩余的秒数，在进程被信号中断的时候，返回剩余秒数

三、信号阻塞和未决信号

信号阻塞：所谓的信号阻塞是进程对某一个或一些信号进行阻塞。

进程调用"sigprocmask"函数设置对信号的阻塞

"sigprocmask"(2)

#include <signal.h>

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

功能：检测或改变为阻塞的信号

参数：

类型sigset_t /* 集合类型，用于标识信号的阻塞和未决状态 */

"how" 
SIG_BLOCK 将进程当前的信号组合集合和set指定的集合/*合并*/
SIG_UNBLOCK 将set集合里指定的信号从进程当前阻塞的信号集里/*移除*/解除set信号集里指定的信号的阻塞
SIG_SETMASK 将进程阻塞的信号集/*设置为参数set的集合*/

"set" 要操作的/*新的信号集*/

"oldset" 如果oldset非空，将进程的原先的阻塞信号集/*存储*/到oldset指定的集合里；如果oldset是 NULL，则不会存储原来的信号阻塞集

返回值：

成功 - 返回 0

失败 - 返回 -1

/*举例验证，阻塞进程中的2号信号，sig2.c*/

#include <stdio.h>

#include <signal.h>

void handle(int signum) {

    printf(" recv signum: %d\n", signum); 

    return ;

}

int main(void) {

    sigset_t set;

    //初始化信号集set

    sigemptyset(&set);

    //向set信号集里添加2号信号

    sigaddset(&set, SIGINT);

    //注册2号信号的处理函数为handle

    signal(2, handle);

    //将信号集合set设置为当前进程的阻塞集合

    sigprocmask(SIG_SETMASK, &set, NULL);

    while(1);

    return 0;

}

"未决信号"

信号产生了，但是信号还没有被递达，这时候信号的状态称为未决状态，这个信号称为未决信号。

对"sigset_t类型的操作函数(3)"使用下列：

"sigemptyset" //初始化，清空信号集

#include <signal.h>

int sigemptyset(sigset_t *set);

功能：将集合里的成员全部清空

参数："set" 指定的信号集合

返回值：

成功 - 返回 0

失败 - 返回 -1

"sigfillset" //填充信号集

#include <signal.h>

int sigfillset(sigset_t *set);

功能：将集合的所有成员全部填充

参数："set" 指定的信号集合

返回值：

成功 - 返回 0

失败 - 返回 -1

"sigaddset" //添加信号到信号集

#include <signal.h>

int sigaddset(sigset_t *set, int signum);

功能：将signum信号添加到set指定的集合里

参数：

"set" 指定的信号集合

"signum" 指定的信号编号

返回值：

成功 - 返回 0

失败 - 返回 -1

"sigdelset" //删除信号集里指定的信号

#include <signal.h>

int sigdelset(sigset_t *set, int signum);

功能：从set指定的集合里将signum指定的信号编号删除

参数：

"set" 指定的信号集合

"signum" 指定的信号编号

返回值：

成功 - 返回 0

失败 - 返回 -1

"sigismember" //测试信号是否是信号集里的成员

#include <signal.h>

int sigismember(const sigset_t *set, int signum);

功能：测试signum是否是set集合里的一个成员

参数：

"set" 指定的信号集合

"signum" 指定的信号编号

返回值：

成功 - 返回 1 代表signum是set集合的成员，0 代表不是。

失败 - 返回 -1

"检测信号是否处于未决状态"，需要使用sigpending函数：

"sigpending"(2)

#include <signal.h>

int sigpending(sigset_t *set);

功能：检测未决信号

参数："set" 未决信号集被返回到set指定的集合里

返回值：

成功 - 返回 0

失败 - 返回 -1

/*举例验证未决信号，对2号信号阻塞时进行检测 sigpending.c*/

#include <stdio.h>

#include <signal.h>

void handle(int signum) {

    printf(" recv signum: %d\n", signum);

    return ;

}

int main(void) {

    sigset_t set, pset;//pset用于检测

    //向进程注册2号信号的处理函数为handle

    signal(2, handle);

    //初始化set集合为空

    sigemptyset(&set);

    //将2号信号添加到集合set里

    sigaddset(&set, 2); 

    //设置进程对信号的阻塞的集合

    sigprocmask(SIG_BLOCK, &set, NULL);

    while(1) {

        //检测进程的未决信号，将未决信号添加到pset的集合里

        sigpending(&pset);

        //检测2号信号是否处于未决状态

        int r = sigismember(&pset, 2); 

        if(r > 0) {

            printf("检测到2号信号为未决信号！\n");
break;

        }   

    }   

    return 0;

}

"可靠信号"：

当在进程中设置了对某个信号阻塞，当有同一个信号多次到达的时候，解除信号阻塞的时候，"会有1个信号的多次捕获"。

此为可靠信号(34-64 号)。

"不可靠信号"：

当在进程中设置了对某个信号阻塞，当有同一个信号多次到达的时候，解除信号阻塞的时候，"对这个信号只有1次捕获，造成了信号的丢失"。

此为不可靠信号(1-31 号)。

/*举例验证，可靠信号与不可靠信号，kekao.c*/

#include <stdio.h>

#include <signal.h>

void handle(int signum) {

    printf("recv signum: %d\n", signum);

    return ;

}

int main(void) {

    sigset_t set, oset;

    signal(35, handle);//1-31信号，发送多次，捕获1次

    sigemptyset(&set);

    sigaddset(&set, 35);

    sigemptyset(&oset);

    sigprocmask(SIG_SETMASK, &set, &oset);

    sleep(20);

    sigprocmask(SIG_SETMASK, &oset, NULL);//恢复原来的信号

    return 0;

}