Linux操作系统 - ＞ 进程信号（中）

阻塞信号

信号其他相关概念

实际执行信号的处理动作称为信号递达

信号从产生到递达之间的状态，称为信号未决

进程可以选择阻塞某个信号

被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作

注意，阻塞和忽略是不同的，只要信号被阻塞就不会递达，而忽略是在抵达之后可选的一种处理动作

eg：

1. 正常情况（不阻塞）

   快递员打电话："你的快递到了（信号产生）。"

   你直接签收并拆开处理（递达 ，执行默认/忽略/自定义动作）。

   → 没有未决，没有阻塞。

2. 阻塞但还没来快递

   你出门前给门卫说："所有快递员的电话我都先不接（阻塞某个信号 ）。"

   此时没快递来，阻塞状态就空在那里。

3. 阻塞期间来快递

   快递员打电话（信号产生），但你处于"不接电话"状态（阻塞）。

   包裹被放进快递柜（未决状态 ）。

   你一直不解除阻塞 → 快递就一直放在柜子里（信号永远不递达）。

4. 解除阻塞

   你回到家，对门卫说："解除不接电话（解除阻塞）。"

   快递员再次通知你（或者系统立即检查未决信号），你从快递柜取出包裹并签收（递达）。

5. 阻塞 ≠ 忽略

   • 阻塞：包裹还在快递柜（未决），你都没见到包裹。

   • 忽略：你签收了包裹（递达了），但看都不看就扔进垃圾桶（动作是"忽略"）。

信号抵达的方式有：默认，忽略，自定义捕捉，进程可以允许某些信号不会被递达(阻塞)，此时这些信号是阻塞信号，保持在未决状态，直到解除阻塞(方可递达)，被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作。

注意：

阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作

在内核中的表示

前面我们说过进程在接受到信号后，可能不是立即处理信号，而是将信号保存起来，是在进程控制快中保存

每个信号都有两个标志位分别是阻塞(block)和未决(pending)，还有一个函数指针表示处理动作。信号产生时候，内核在进程控制快中设置该信号的未决标志，直到信号抵达才清楚标志

在上图的例子中：

• SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作。
• SIGINT信号产生了，但正在被阻塞，所以暂时不能递达。虽然它的处理动作是忽略，但在没有解除阻塞之前
• 不能忽略这个信号，因为进程仍有机会改变处理动作之后再解除阻塞。
• SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞，它的处理动作是用户自定义函数sighandler。

如果在进程解除对某信号的阻塞之前这种信号产生过多次，将如何处理?

Linux是这样实现的:

常规信号在递达之前产生多次只计一次，而实时信号在递达之前产生多次可以依次放在一个队列里。

pending位图：比特位的位置代表信号的编号，比特位的内容(0 or 1)代表是否收到信号，OS发送信号本质是修改task_struct pending位图的内容

handler数组：用信号的编号，作为数组的索引，找到该信号对应的信号处理方式，然后指向对应的方法(递达)

block位图：比特位的位置代表信号的编号，比特位的内容(0 or 1) 代表是否阻塞该信号

注意：

如果没有收到对应的信号，照样可以阻塞特定信号，阻塞更准确的理解成一种"状态"，检测信号是否会被递达，是否被阻塞，都是OS的任务，信号的自定义捕捉方式是用户提供的！是在用户的权限下对应的方法

sigset_t信号集

信号集用来描述信号的集合，每个信号占用一位。从上图来看，每个信号只有一个bit的未决标志,非0即1，不记录该信号产生了多少次,阻塞标志也是这样表示的。因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储，sigset_t称为信号集

这个类型可以表示每个信号的"有效"或"无效"状态,在阻塞信号集中"有效"和"无效"的含义是该信号是否被阻塞,而在未决信号集中"有效"和"无效"的含义是该信号是否处于未决状态。下面将详细介绍信号集的各种操作。 阻塞信号集也叫做当前进程的信号屏蔽字(Signal Mask),这里的"屏蔽"应该理解为阻塞而不是忽略。

我们写程序创建sigset_t变量，本质上是在栈上开辟的空间创建的他，是在用户空间，我们设置进程属性还需要系统调用接口

int main()
{
    sigset_t set;//在栈上开辟空间，用户空间，设置进程属性(OS)，系统调用接口
    return 0;
}

信号集操作函数

sigset_t类型对于每种信号用一个bit表示"有效"或"无效"状态,至于这个类型内部如何存储这些bit则依赖于系统

实现,从使用者的角度是不必关心的,使用者只能调用以下函数来操作sigset_ t变量,而不应该对它的内部数据做

任何解释,比如用printf直接打印sigset_t变量是没有意义的

这些操作函数只是在用户空间上的，修改的是用户空间的变量

#include <signal.h>
int sigemptyset(sigset_t *set);

函数sigemptyset初始化set所指向的信号集,使其中所有信号的对应bit清零,表示该信号集不包含任何有 效信号。

#include <signal.h>
int sigfillset(sigset_t *set);

函数sigfillset初始化set所指向的信号集,使其中所有信号的对应bit置位,表示该信号集的有效信号包括系 统支持的所有信号。

注意：

在使用sigset_ t类型的变量之前,一定要调用sigemptyset或sigfillset做初始化,使信号集处于确定的状态。初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号

#include <signal.h>
int sigaddset (sigset_t *set, int signo);

指定位置设置为1(添加信号)

#include <signal.h>
int sigdelset(sigset_t *set, int signo);

指定位置设置为0(删除信号)

#include <signal.h>
int sigismember（const sigset_t *set, int signo);

判断特定信号是否已经被设置

这四个函数都是成功返回0,出错返回-1。sigismember是一个布尔函数,用于判断一个信号集的有效信号中是否包含

某种 信号,若包含则返回1,不包含则返回0,出错返回-1。

这些都只是语言层面的操作函数，我们需要设置进程属性的话就需要系统调用接口：

sigprocmask

调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集)。

#include <signal.h>

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

返回值:若成功则为0,若出错则为-1

set是输入型参数，oset是输出型参数：

如果oset是非空指针,则读取进程的当前信号屏蔽字通过oset参数传出。如果set是非空指针,则更改进程的信

号屏蔽字,参数how指示如何更改。如果oset和set都是非空指针,则先将原来的信号屏蔽字备份到oset里,然后

根据set和how参数更改信号屏蔽字。假设当前的信号屏蔽字为mask,下表说明了how参数的可选值：

sigpending

#include <signal.h>
int sigpending(sigset_t *set);

读取当前进程的未决信号集，通过set参数传出。调用成功则返回0,出错则返回-1。 下面用刚学的几个函数写个程序。程

序如下:

程序的步骤：

使用sigprocmask系统调用接口屏蔽(阻塞)2号信号

使用sigpending接口不断的获取pending信号集，并打印，0000000000000000000

发送2号信号给进程(2号进程是无法递达的)，就能看到一个现象：0100000000000000000000

#include<signal.h>
#include<iostream>
using namespace std;
void show_pending(sigset_t *pending)
{
    for(int i = 1;i <= 31;i++)
    {
        if(sigismember(pending,i))
        {
            cout<<"1";
        }
        else
        {
            cout<<"0";
        }
    }
    cout<<endl;
}
int main()
{
    sigset_t in,out;//定义变量表示阻塞信号，in阻塞信号集：out是旧的阻塞信号集(输出型参数)
    sigemptyset(&in);//初始化阻塞信号集所有位为0
    sigemptyset(&out);//初始化未决信号集所有位为0
    
    sigaddset(&in,2);//设置2号信号被block，user stack，用户栈上设置，不影响内核
    
    sigprocmask(SIG_SETMASK,&in,&out);//在内核中完成2号block
    sigset_t pending;
    while(1)
    {
        sigpending(&pending);//读取当前进程的未决信号集
        sleep(1);//每隔一秒打印一下当前进程的未决信号集
        show_pending(&pending);
    }
    return 0;
}

首先要打印0000000000000000000000000000000，因为此时2号信号是阻塞状态，我们还没有发送2号状态，所以刚开始未决信号集打印的是0000000000000000000000000000000，然后当我们发送2号信号时打印的是0100000000000000000000000000000，因为2号是被设置为阻塞，只能处于未决，不能递达：

接下来我们再添加一些步骤：

1. 过一段时间，取消对2号信号的block
2. 2号信号立马会被递达
3. 然后依旧打印pending位图，010000000->000000000

第五步需要考虑一下2号信号的默认处理

void show_pending(sigset_t *pending)
{
    for(int i = 1;i <= 31;i++)
    {
        if(sigismember(pending,i))
        {
            cout<<"1";
        }
        else
        {
            cout<<"0";
        }
    }
    cout<<endl;
}
int main()
{
    signal(2,handler);
    sigset_t in,out;
    sigemptyset(&in);
    sigemptyset(&out);
    
    sigaddset(in,2);//设置2号信号被block，user stack，用户栈上设置，不影响内核
    
    
    sigprocmask(SIG_SETMASK,&in,&out);//在内核中完成2号block
    int count = 0;
    sigset_t pending;
    while(1)
    {
        sigpending(&pending);
        sleep(1);
        show_pending(&pending);//每隔一秒打印一下当前进程的未决信号集
        if(count == 20)
        {
            //20秒之后会恢复2号信号
            sigprocmask(SIG_SETMASK,&out,&in);//恢复之后，2号信号立马递达，并且执行默认动作
            //恢复之后in又变成了老的阻塞信号集
            cout<<"old: ";
            show_pending(&in);//打印in信号集 010000000000...
            cout<<"new: ";
            show_pending(&out);  //打印out信号集 0000000000...
        }
        count++;
    }
    return 0;
}

我们分析一下程序：首先每隔一秒打印一下当前进程的未决信号集00000...，然后我们发送2号信号，此时未决信号集发生变化打印01000000...，然后20秒之后，将2号信号恢复，恢复之后in又变成了老的阻塞信号集，out是新的阻塞信号集，打印in信号集即0100000...，打印out信号集00000...

看打印结果：

我们发现20秒之后程序直接退出了，并没有打印old和in，当count等于20时，恢复了2号信号，2号信号是终止进程，恢复了2号信号，2号信号完成递达，我们没有自定义捕获信号，所以默认处理，即终止了进程。

我们写了自定义捕获信号后，就不会终止进程，会继续打印in信号集和out信号集了：

void show_pending(sigset_t *pending)
{
    for(int i = 1;i <= 31;i++)
    {
        if(sigismember(pending,i))
        {
            cout<<"1";
        }
        else
        {
            cout<<"0";
        }
    }
    cout<<endl;
}
//自定义处理方式：捕获：
void handler(int signo)
{
	std::cout << "get a signal: " << signo << std::endl ; 
}
int main()
{
    signal(2,handler);
    sigset_t in,out;
    sigemptyset(&in);
    sigemptyset(&out);
    
    sigaddset(in,2);//设置2号信号被block，user stack，用户栈上设置，不影响内核
     
    sigprocmask(SIG_SETMASK,&in,&out);//在内核中完成2号block
    int count = 0;
    sigset_t pending;
    while(1)
    {
        sigpending(&pending);
        sleep(1);
        show_pending(&pending);//每隔一秒打印一下当前进程的未决信号集
        if(count == 20)
        {
            //20秒之后会恢复2号信号
            signal(2,handler);//自定义捕获2号信号
            sigprocmask(SIG_SETMASK,&out,&in);//恢复之后，2号信号立马递达，并且执行默认动作
            //恢复之后in又变成了老的阻塞信号集
            cout<<"old: ";
            show_pending(&in);//打印in信号集 010000000000...
            cout<<"new: ";
            show_pending(&out);  //打印out信号集 0000000000...
        }
        count++;
    }
    return 0;
}