秒懂Linux之信号

信号的基本概念

信号的处理方式

默认动作

自定义处理信号

忽略该信号

信号的产生方式

kill命令

键盘组合键

系统调用

软件条件

异常

信号产生的深层理解

core的功能

信号的阻塞

内核中的表示

sigset_t

信号集操作函数

sigprocmask

sigpending

模拟场景

信号的捕捉

用户态与内核态

sigaction

可重入函数

volatile

SIGCHLD信号

信号的基本概念

信号是Linux系统提供的让用户（进程）给其他进程发送异步消息的一种方式

在没有发生的时候，我们就已经知道发生时该如何处理了（就比如古代看到狼烟点起我们就知道发生什么并做出对应措施~）
我们（进程）之所以能够认识信号是因为设置了识别特定信号的方式
信号到了的时候，如果我们正在处理更重要的事情，我们可以对暂时无法处理的信号进行临时保存，这意味着信号到来可以延时处理~
信号的产生是随时的，我们无法预料到，所以信号是异步发送的（信号是由别人产生的，我们收到之前会一直在忙自己的事情，是并发式的

进程在运行期间会经历以下阶段：

准备——>信号的产生——>信号的保存——>信号的处理~

准备阶段：

实时信号就是必须立马处理~

信号的处理方式

信号的处理方式有以下三种：

默认动作

我们在一个进行执行死循环语句时给它发送信号，例如编号为9的sigkill，当进程识别该信号时就会做出默认的，与之匹配的处理动作——杀死进程~又或者是终止进程等等~
int main()
{
    while(1)
    {
        sleep(1);
        cout<<"aaa ,pid:"<<getpid()<<endl;
    }
    return 0;
}

自定义处理信号

我们也可以去修改进程接收到信号的默认动作~

signal函数本质是根据修改的信号让其进入handler回调函数来实现信号的自定义处理~
void handler(int signo)
{
    //不终止进程，而是让该信号打印一句话
    cout<<"hello"<<endl;
}

int main()
{
    signal(SIGINT, handler);
    while(1)
    {
        sleep(1);
        cout<<"aaa ,pid:"<<getpid()<<endl;
    }
    return 0;
}
需要注意的是调用signal后回调函数handler并不会立刻执行，而是等接收到对应的信号才执行~

忽略该信号

不再使用回调函数，而是用SIG_IGN表示忽略


void handler(int signo)
{
    //不终止进程，而是让该信号打印一句话
    cout<<"hello"<<endl;
}

int main()
{
    //signal(SIGINT, handler);

    signal(SIGINT, SIG_IGN);

    while(1)
    {
        sleep(1);
        cout<<"aaa ,pid:"<<getpid()<<endl;
    }
    return 0;
}

信号的产生方式

kill命令

系统内部已经设置好的相关信号命令~

键盘组合键

在终端键入Ctrl-C或Ctrl-\或Ctrl-Z等组合键会触发和kill命令一样的效果~

系统调用

kill函数：向任意进程发送任意信号

// mytest -9 pid
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        cout << "Usage: " << argv[0] << " -signumber pid" << endl;
        return 1;
    }
    //获取自定义信号的编号
    int signumber = stoi(argv[1] + 1);
    int pid = stoi(argv[2]);
    sleep(3);
    int n = kill(pid, signumber);
    if (n < 0)
    {
        cerr << "kill error, " << strerror(errno) << endl;
    }

    return 0;
}

raise函数：对自己发送任意信号

void handler(int signumber)
{
    //自定义处理，打印一句话
    std::cout << " get a signal, number is : " << signumber << std::endl;
}

int main()
{
    //识别到信号2后捕捉转回调函数
    signal(2, handler);
    int cnt = 0;
    while(true)
    {
        cout << "cnt: " << cnt++ << endl;
        sleep(1);
        if(cnt % 5 == 0) 
        {
            cout << "send 2 to caller" << endl;
            //每隔5s就给自己发送一次终止信号：SIGINT
            raise(2); 
        }
    }
}

abort 函数：使当前进程接收到信号而异常终止，类似exit函数


void handler(int signumber)
{
    //自定义处理，打印一句话
    std::cout << " get a signal, number is : " << signumber << std::endl;
}

int main()
{
    //识别到信号2后捕捉转回调函数
    signal(2, handler);
    int cnt = 0;
    while(true)
    {
        cout << "cnt: " << cnt++ << endl;
        sleep(1);
        if(cnt % 5 == 0) 
        {
            cout << "send 2 to caller" << endl;
            //每隔5s就给自己发送一次终止信号：SIGINT
            //raise(2); 
            abort();
        }
    }
}

软件条件

比如我们之前所接触的管道通信，在读端停止读取且关闭的情况下写端已经没有任何意义了，这时候系统就会发送信号13（SIGPIPE）来终止自己。

下面我们再来介绍一下alarm函数与SIGALRM信号

调用alarm函数可以设定一个闹钟,也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号, 该信号的默认处理动作是终止当前进程。

这个函数的返回值是0或者是以前设定的闹钟时间还余下的秒数~
int main()
{
    // 设定一个闹钟

    alarm(3); // 只响一次

    int cnt = 0;
    while(true)
    {
        sleep(1);
        cout << "cnt : " << cnt++ << ", pid is : "<< getpid() << endl; 
        if(cnt == 5)
        {
            int n = alarm(0); // alarm(0): 取消闹钟
            cout << " alarm(0) ret : " << n << endl;
        }
    }
}
如果本该在100s后响起的闹钟被我们提前发送信号让signal误以为响了，就可以看到剩余时间了。
void handler(int sig)
{
    std::cout << "get a sig: " << sig << std::endl;
    unsigned int n = alarm(5);

    cout << "还剩多少时间: " << n << endl;
    // exit(0);
}

int main()
{
    // 设定一个闹钟
    signal(SIGALRM, handler);
    alarm(100); // 只响一次

    int cnt = 0;
    while (true)
    {
        sleep(1);
        cout << "cnt : " << cnt++ << ", pid is : " << getpid() << endl;
        
    }
}
alarm(0)为取消闹钟
void handler(int sig)
{
    std::cout << "get a sig: " << sig << std::endl;
    unsigned int n = alarm(5);

    cout << "还剩多少时间: " << n << endl;
    // exit(0);
}

int main()
{
    // 设定一个闹钟
    signal(SIGALRM, handler);
    alarm(100); // 只响一次

    int cnt = 0;
    while (true)
    {
        sleep(1);
        cout << "cnt : " << cnt++ << ", pid is : " << getpid() << endl;
        if(cnt==2)
        {
            int n = alarm(0);//取消闹钟
            cout<<"alarm(0) ret :"<<n<<endl;
        }
    }
}
关于设定闹钟因为其本质是系统调用，所以是由OS设定的，而一个进程可以同时存在多个闹钟，这时候就需要OS对其进行管理——先描述，再组织。通过当前时间戳与其未来将要过期的时间戳作对比来决定先后顺序，所以组织的方式可以以最小堆的方式进行~

异常

代码除零 8）SIGFPE

int main()
{
    int a = 0;
    a/=0;
    while(1)
    {
        sleep(1);
    }
    return 0;
}

在捕获后异常并不会消失，所以会一直出现

void handler(int sig)
{
    cout<<"get a sig:"<<sig<<endl;
}


int main()
{
    //捕获
    signal(SIGFPE,handler);
    int a = 0;
    a/=0;
   
    return 0;
}

野指针 11）SIGSEGV
int main()
{
    int *p = nullptr;
    *p  = 10;
}
void handler(int sig)
{
    cout<<"get a sig:"<<sig<<endl;
    exit(1);
}

int main()
{
    //捕获
    signal(SIGSEGV,handler);
    int *p = nullptr;
    *p  = 10;
}
由此可以确认，我们在 C/C++ 当中除零，内存越界等异常，在系统层面上，是被当成信号处理的~

信号产生的深层理解

举例键盘产生信号：

其实当我们无法及时处理信号时，它就会被保存到进程的PCB中~

与其说是给进程发送信号，实际上是写入信号——通过修改位图中的数据，但PCB内为内核数据，只有OS才有资格写入，用户要想写入信号就得依靠OS提供的系统调用。归根到底，无论信号有多少种产生方式，最终都是由OS往进程内写入信号的~

举例异常产生信号：

core的功能

我们可以看到在信号列表中core与term都是代表进程终止的意思，不过core还有额外的功能~

int main()
{
    cout<<"run begin..."<<endl;
    int a = 10;
    a/= 0;
    cout<<"run end..."<<endl;
    while(1)
    {
        sleep(1);
    }
    return 0;
}

core是将进程在内存中的核心数据（用于调试）转储到磁盘中形成core文件，届时就可以在进程异常退出时通过对core文件调试来定位进程为什么退出以及在哪行代码退出~

我们再回到之前所学的进程就可以理解core dump标志的含义了，若为1则代表进程被信号终止时core功能发挥把核心数据转储到磁盘并生成core文件~

int main()
{
    pid_t id = fork();
    if (id == 0)
    {
        sleep(2);
        int a = 10;
        a /= 0; // 故意异常，收到SIGFPE-> core
        exit(0);
    }

    // father
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if (rid > 0)
    {
        std::cout << "exit code: " << ((status >> 8) & 0xFF) << std::endl; // 没有意义
        std::cout << "exit signal: " << (status & 0x7F) << std::endl;
        std::cout << "core dump: " << ((status >> 7) & 0x1) << std::endl;
    }
    return 0;
}

信号的阻塞

内核中的表示

注意：Block与Pending无任何关联关系~

每个信号都有两个标志位分别表示阻塞(block)和未决(pending),还有一个函数指针表示处理动作。信号产生时,内核在进程控制块中设置该信号的未决标志,直到信号递达才清除该标志。在上图的例子中,SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作。

SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞。

SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler。如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?POSIX.1允许系统递送该信号一次或多次。Linux是这样实现的:常规信号在递达之前产生多次只计一次~

信号最终是以这三张表的形式呈现，而OS掌管对信号的写入——对位图数据的修改，如果我们也想去修改block与pending呢？——借助OS的系统调用~

sigset_t

从上图来看 , 每个信号只有一个 bit 的未决标志 , 非 0 即 1, 不记录该信号产生了多少次 , 阻塞标志也是这样表示的。

因此 , 未决和阻塞标志可以用相同的数据类型 sigset_t 来存储 ,sigset_t 称为信号集 , 这个类型可以表示每个信号的“ 有效 ” 或 “ 无效 ” 状态 , 在阻塞信号集中 “ 有效 ” 和 “ 无效 ” 的含义是该信号是否被阻塞 , 而在未决信号集中 “ 有效” 和 “ 无效 ” 的含义是该信号是否处于未决状态。

信号集操作函数

#include <signal.h>

int sigemptyset(sigset_t *set);

int sigfillset(sigset_t *set);

int sigaddset (sigset_t *set, int signo);

int sigdelset(sigset_t *set, int signo);

int sigismember （ const sigset_t *set, int signo);

函数sigemptyset初始化set所指向的信号集,使其中所有信号的对应bit清零,表示该信号集不包含任何有效信号。
函数sigﬁllset初始化set所指向的信号集,使其中所有信号的对应bit置位,表示该信号集的有效信号包括系统支持的所有信号。
注意,在使用sigset_ t类型的变量之前,一定要调用sigemptyset或sigﬁllset做初始化,使信号集处于确定的状态。初始化sigset_t变量之后就可以在调用sigaddset和sigdelset在该信号集中添加或删除某种有效信号。
这四个函数都是成功返回0,出错返回-1。sigismember是一个布尔函数,用于判断一个信号集的有效信号中是否包含某种信号,若包含则返回1,不包含则返回0,出错返回-1

sigprocmask

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

#include <signal.h>

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

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

如果oset是非空指针,则读取进程的当前信号屏蔽字通过oset参数传出。如果set是非空指针,则更改进程的信号屏蔽字,参数how指示如何更改。如果oset和set都是非空指针,则先将原来的信号屏蔽字备份到oset里,然后根据set和how参数更改信号屏蔽字。假设当前的信号屏蔽字为mask,下表说明了how参数的可选值。

如果调用 sigprocmask 解除了对当前若干个未决信号的阻塞 , 则在 sigprocmask 返回前 , 至少将其中一个信号递达。

sigpending

#include <signal.h>

sigpending

读取当前进程的未决信号集 , 通过 set 参数传出。调用成功则返回 0, 出错则返回 -1 。

模拟场景

屏蔽2号信号
未来给进程发送2号信号——屏蔽2号信号——2号信号无法递达——2号信号会一直保存在pending位图中
获取进程的pending位图
打印所有pending位图中的信号

int main()
{
    //1.屏蔽2号信号
    //准备工作
    sigset_t block,oblock;
    //初始化
    sigemptyset(&block);
    sigemptyset(&oblock);
    //对该位图中的2号信号位置1
    sigaddset(&block,2);//还没设置进当前进程的PCB block位图中
    //设置进内核中，完成2号信号的屏蔽工作
    sigprocmask(SIG_SETMASK,&block,&oblock);

}

void PrintSig(sigset_t &pending)
{
    cout << "Pending bitmap: ";
    for (int signo = 31; signo > 0; signo--)
    {
        if (sigismember(&pending, signo))
        {
            cout << "1";
        }
        else
        {
            cout << "0";
        }
    }
    cout << endl;
}

int main()
{
    // 1.屏蔽2号信号
    // 准备工作
    sigset_t block, oblock;
    // 初始化
    sigemptyset(&block);
    sigemptyset(&oblock);
    // 对该位图中的2号信号位置1
    sigaddset(&block, 2); // 还没设置进当前进程的PCB block位图中
    // 设置进内核中，完成2号信号的屏蔽工作
    int n = sigprocmask(SIG_SETMASK, &block, &oblock);
    assert(n == 0);
    cout << "block 2 signal success" << endl;
    cout << "pid: " << getpid() << endl;
    while (true)
    {
        // 2.获取进程的pending位图
        sigset_t pending;
        sigemptyset(&pending);
        n = sigpending(&pending);
        assert(n == 0);

        // 3. 打印pending位图中的收到的信号
        PrintSig(pending);
        sleep(1);
    }
}

在2信号没有产生之前可以看到pending位图没有接收到任意一个信号，而当我们输入kill指令后位图发生了变化~

但还是继续打印，并没有出现终止进程的效果，说明我们阻塞成功了~

我们再来实验一下把所有信号都阻塞~

void PrintSig(sigset_t &pending)
{
    cout << "Pending bitmap: ";
    for (int signo = 31; signo > 0; signo--)
    {
        if (sigismember(&pending, signo))
        {
            cout << "1";
        }
        else
        {
            cout << "0";
        }
    }
    cout << endl;
}

int main()
{
    // 1.屏蔽2号信号
    // 准备工作
    sigset_t block, oblock;
    // 初始化
    sigemptyset(&block);
    sigemptyset(&oblock);
    //0. 如果我屏蔽了所有信号呢？？？
    for(int signo = 1; signo <= 31; signo++) // 9， 19号信号无法被屏蔽， 18号信号会被做特殊处理
        sigaddset(&block, signo);
    /* // 对该位图中的2号信号位置1
    sigaddset(&block, 2); // 还没设置进当前进程的PCB block位图中 */
    // 设置进内核中，完成2号信号的屏蔽工作
    int n = sigprocmask(SIG_SETMASK, &block, &oblock);
    assert(n == 0);
    cout << "block 2 signal success" << endl;
    cout << "pid: " << getpid() << endl;
    while (true)
    {
        // 2.获取进程的pending位图
        sigset_t pending;
        sigemptyset(&pending);
        n = sigpending(&pending);
        assert(n == 0);

        // 3. 打印pending位图中的收到的信号
        PrintSig(pending);
        sleep(1);
    }
}

直接说结果：pending位图中9号信号与19号信号无法阻塞，18号信号会作特殊处理~其位上内容仍然为0是发送kill指令后完成看了信号递达清除了标志，并没有一直因为未处理而保存在pending位图中~

这是合理的，如果把所有信号都阻塞了那么就只能等进程自己退出了，想想也不契合实际~

下面我们来尝试解除2号信号的阻塞

int main()
{
    // 1.屏蔽2号信号
    // 准备工作
    sigset_t block, oblock;
    // 初始化
    sigemptyset(&block);
    sigemptyset(&oblock);
    //0. 如果我屏蔽了所有信号呢？？？
    for(int signo = 1; signo <= 31; signo++) // 9， 19号信号无法被屏蔽， 18号信号会被做特殊处理
        sigaddset(&block, signo);
    /* // 对该位图中的2号信号位置1
    sigaddset(&block, 2); // 还没设置进当前进程的PCB block位图中 */
    // 设置进内核中，完成2号信号的屏蔽工作
    int n = sigprocmask(SIG_SETMASK, &block, &oblock);
    assert(n == 0);
    cout << "block 2 signal success" << endl;
    cout << "pid: " << getpid() << endl;
    int cnt =0;
    while (true)
    {
        // 2.获取进程的pending位图
        sigset_t pending;
        sigemptyset(&pending);
        n = sigpending(&pending);
        assert(n == 0);

        // 3. 打印pending位图中的收到的信号
        PrintSig(pending);
        cnt++;
        // 4. 解除对2号信号的屏蔽
        if (cnt == 20)
        {
            std::cout << "解除对2号信号的屏蔽" << std::endl;
            n = sigprocmask(SIG_UNBLOCK, &block, &oblock); // 2号信号会被立即递达, 默认处理是终止进程
            assert(n == 0);
        }


        sleep(1);
    }
}

20s前输入kill指令发现2号信号被阻塞了不得不保存在pending中，20s后解除对2号信号的阻塞，让保存着的2号信号进行信号递达——终止进程~

对2号信号进行捕获

void PrintSig(sigset_t &pending)
{
    cout << "Pending bitmap: ";
    for (int signo = 31; signo > 0; signo--)
    {
        if (sigismember(&pending, signo))
        {
            cout << "1";
        }
        else
        {
            cout << "0";
        }
    }
    cout << endl;
}
void handler(int signo)
{
    cout << signo << " 号信号被递达处理..." << endl;
}

int main()
{
    // 对2号信号进行自定义捕捉 --- 不让进程因为2号信号而终止
    signal(2, handler);
    // 1.屏蔽2号信号
    // 准备工作
    sigset_t block, oblock;
    // 初始化
    sigemptyset(&block);
    sigemptyset(&oblock);
    //0. 如果我屏蔽了所有信号呢？？？
    for(int signo = 1; signo <= 31; signo++) // 9， 19号信号无法被屏蔽， 18号信号会被做特殊处理
        sigaddset(&block, signo);
    /* // 对该位图中的2号信号位置1
    sigaddset(&block, 2); // 还没设置进当前进程的PCB block位图中 */
    // 设置进内核中，完成2号信号的屏蔽工作
    int n = sigprocmask(SIG_SETMASK, &block, &oblock);
    assert(n == 0);
    cout << "block 2 signal success" << endl;
    cout << "pid: " << getpid() << endl;
    int cnt =0;
    while (true)
    {
        // 2.获取进程的pending位图
        sigset_t pending;
        sigemptyset(&pending);
        n = sigpending(&pending);
        assert(n == 0);

        // 3. 打印pending位图中的收到的信号
        PrintSig(pending);
        cnt++;
        // 4. 解除对2号信号的屏蔽
        if (cnt == 20)
        {
            std::cout << "解除对2号信号的屏蔽" << std::endl;
            n = sigprocmask(SIG_UNBLOCK, &block, &oblock); // 2号信号会被立即递达, 默认处理是终止进程
            assert(n == 0);
        }


        sleep(1);
    }
}

信号的捕捉

信号是什么时候被处理的呢？——当进程从内核态切换到用户态的时候，信号就会被检测并处理~

并不是只有用系统调用才会进入内核态，进程是要被调度的，所以这种场景也是会进入内核态的

若信号的处理动作是用户自定义函数 , 在信号递达时就调用这个函数 , 这称为捕捉信号。由于信号处理函数的代码是在用户空间的, 处理过程比较复杂 , 举例如下 : 用户程序注册了 SIGQUIT 信号的处理函数 sighandler 。当前正在执行main函数 , 这时发生中断或异常切换到内核态。

在中断处理完毕后要返回用户态的 main 函数之前检查到有信号SIGQUIT递达。内核决定返回用户态后不是恢复 main 函数的上下文继续执行 , 而是执行 sighandler 函数 ,sighandler和main 函数使用不同的堆栈空间 , 它们之间不存在调用和被调用的关系 , 是两个独立的控制流程。

sighandler 函数返回后自动执行特殊的系统调用sigreturn 再次进入内核态。如果没有新的信号要递达 , 这次再返回用户态就是恢复main函数的上下文继续执行了。

那为什么在信号捕捉期间执行到我们的自定义方法时需要从内核态切换为用户态呢？

因为这个方法是用户写的，你无法保证是否会非法访问OS，OS不允许也不信任任何人，同样的它也不会以它的身份来执行你的方法，所以才需要切换到用户态去调用方法。

另外提一嘴，大多数信号的SIG_DFL都是杀死进程，少数是暂停的，那么既然要杀死进程为什么不直接点呢？还得往pending位图写入1，让进程去决定是否执行SIG_DFL呢？

当进程准备处理完一件重要的事情再退出的时候突然被你紧急杀死肯定会出问题，所以才会给进程一个响应的时间，避免重要的事情半途而废。

用户态与内核态

首先，OS是开机时就加载进内存的，而为了让用户能以安全姿态去访问OS，必须把OS数据通过页表映射到[3,4]G的地址空间中，我们把这部分区域划定为内核空间，只允许内核态访问，下面的3G划分为用户空间，只允许用户态访问~

当正文发现系统调用时就会拿着下标与虚拟地址到内核中找到该表对应的指针让OS执行方法，最后再返回到用户~

这说明一个观点：我们在使用系统调用或访问系统数据时，都是在当前进程的地址空间中跳转的！

那若是其他的进程呢？——每个进程都有PCB,地址空间，但OS只有一份。因此，任意进程都是共同访问同一个内核级页表，每个进程的用户空间数据可以不同，但内核空间数据一定相同~无论进程如何切换，总能找到OS，访问OS本质就是通过自己的地址空间中的内核空间来访问~

先来说一个结论：信号技术是通过软件的方式来模拟的硬件中断（提示OS）~

那么对于OS我们再延申一下：是谁让OS运行起来的呢？

所以OS就是个死循环，不断在接受外部的其他硬件中断~

我们再回过头来看结论：之前cpu是通过硬件中断触发通知OS，那能否不通过中断直接在寄存器中生成中断号呢？——内部中断~

最后我们再回归主题：用户态与内核态，这是在cpu中通过独有的标识进行区分的~

我们不可能拿用户态代码去直接访问OS中所有数据，因此当调用系统调用或是被调度什么的时候都是在cpu进行身份转化，用户态由3变0以OS身份访问数据，回来时再由0变回3继续执行正文~

sigaction

#include <signal.h>

int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);

sigaction函数可以读取和修改与指定信号相关联的处理动作。调用成功则返回0,出错则返回- 1。signo是指定信号的编号。若act指针非空,则根据act修改该信号的处理动作。若oact指针非空,则通过oact传出该信号原来的处理动作。act和oact指向sigaction结构体:

将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号,赋值为常数SIG_DFL表示执行系统默认动作,赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册了一个信号处理函数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用。

当某个信号的处理函数被调用时 , 内核自动将当前信号加入进程的信号屏蔽字 , 当信号处理函数返回时自动恢复原来的信号屏蔽字, 这样就保证了在处理某个信号时 , 如果这种信号再次产生 , 那么它会被阻塞到当前处理结束为止。如果在调用信号处理函数时, 除了当前信号被自动屏蔽之外 , 还希望自动屏蔽另外一些信号 , 则用 sa_mask 字段说明这些需要额外屏蔽的信号, 当信号处理函数返回时自动恢复原来的信号屏蔽字。 sa_flags 字段包含一些选项 , 本章的代码都把sa_flags 设为 0,sa_sigaction 是实时信号的处理函数。

void handler(int signo)
{
    cout<<"signal:"<<signo<<endl;
}
int main()
{
    struct sigaction act,oact;
    //自定义对信号处理
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    //对2号信号进行捕捉
    sigaction(2,&act,&oact);

    while(1)
    {
        sleep(1);
    }

    return 0;
}

目前看来与signal没有什么区别~

这是避免在捕捉过程中又来一个信号，然后又对其进行捕捉，这样不断反复会让栈帧越陷越深，索性利用mask，在使用sigacation的时候默认阻塞当前信号~

void Print(sigset_t &pending)
{
    cout << "pid::"<<getpid()<<"curr process pending: ";
    for(int sig = 31; sig >= 1; sig--)
    {
        if(sigismember(&pending, sig)) std::cout << "1";
        else std::cout << "0";
    }
    cout << "\n";
}

void handler(int signo)
{
    cout << "signal : " << signo << endl;
    // 不断获取当前进程的pending信号集合并打印
    sigset_t pending;
    sigemptyset(&pending);
    while(true)
    {
        sigpending(&pending);
        Print(pending);
        sleep(1);
    }
}
int main()
{
    struct sigaction act,oact;
    //自定义对信号处理
    act.sa_handler = handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    //再对信号3进行阻塞
    sigaddset(&act.sa_mask, 3);
    //对2号信号进行捕捉
    sigaction(2,&act,&oact);

    while(1)
    {
        sleep(1);
    }

    return 0;
}

可重入函数

main 函数调用 insert 函数向一个链表 head 中插入节点 node1, 插入操作分为两步 , 刚做完第一步的时候 , 因为硬件中断使进程切换到内核, 再次回用户态之前检查到有信号待处理 , 于是切换到 sighandler 函数,sighandler 也调用 insert 函数向同一个链表 head 中插入节点 node2, 插入操作的两步都做完之后从sighandler返回内核态 , 再次回到用户态就从 main 函数调用的 insert 函数中继续往下执行 , 先前做第一步之后被打断, 现在继续做完第二步。结果是 ,main 函数和 sighandler 先后向链表中插入两个节点 , 而最后只有一个节点真正插入链表中了。

说直白点就是在插入节点时突然捕捉到信号进行自定义处理，在自定义中也进行了插入，insert函数被执行流反复进入导致出问题，这种函数我们称为不可重入函数~

volatile

volatile老熟人了，在c++时我们就讲解过，它是为了防止编译器自作聪明作优化把数据存入寄存器中，导致我们在内存已经修改数据了但它仍是取寄存器那个旧数据~

所以volatile作用为保存内存的可见性~

SIGCHLD信号

进程一章讲过用 wait 和 waitpid 函数清理僵尸进程 , 父进程可以阻塞等待子进程结束 , 也可以非阻塞地查询是否有子进程结束等待清理( 也就是轮询的方式 ) 。采用第一种方式 , 父进程阻塞了就不能处理自己的工作了 ; 采用第二种方式 , 父进程在处理自己的工作的同时还要记得时不时地轮询一下, 程序实现复杂。

void handler(int signo)
{
    cout << "child quit, father get a signo: " << signo << endl;
}

void CleanupChild(int signo)
{
    if (signo == SIGCHLD)
    {
        pid_t rid = waitpid(-1, nullptr, 0);
        if (rid > 0)
        {
            cout << "wait child success: " << rid << endl;
        }
    }
    cout << "wait sub process done" << endl;
}
int main()
{
    signal(SIGCHLD, CleanupChild);

    
    for (int i = 0; i < 100; i++)
    {
        pid_t id = fork();
        if (id == 0)
        {
            // child
            int cnt = 5;
            while (cnt--)
            {
                cout << "I am child process: " << getpid() << endl;
                sleep(1);
            }
            cout << "child process died" << endl;
            exit(0);
        }
    }

    // father
    while (true)
        sleep(1);
}

这样做有个弊端，当多个进程统一退出，统一向父进程发送信号时位图只会把多个信号当作一次，这样就导致只记录了一次，，只回收了一个~

void CleanupChild(int signo)
{
   
    if (signo == SIGCHLD)
    {
        while (true)
        {
            pid_t rid = waitpid(-1, nullptr, 0); // -1 : 回收任意一个子进程
            if (rid > 0)
            {
                cout << "wait child success: " << rid << endl;
            }
            else if(rid <= 0) break;
        }
    }
    cout << "wait sub process done" << endl;
}

当然我们也可以加个循环让其一直回收，直到全部回收完才退出~

但这样只是父进程主动等待，我们可以有更好的做法~

void handler(int sig)
{
    pid_t id;
    while ((id = waitpid(-1, NULL, WNOHANG)) > 0)
    {
        printf("wait child success: %d\n", id);
    }
    printf("child is quit! %d\n", getpid());
}
int main()
{
    signal(SIGCHLD, handler);
...
}

其实,子进程在终止时会给父进程发SIGCHLD信号,该信号的默认处理动作是忽略,父进程可以自定义SIGCHLD信号的处理函数,这样父进程只需专心处理自己的工作,不必关心子进程了,子进程终止时会通知父进程,父进程在信号处理函数中调用wait清理子进程即可。

int main()
{
   // signal(SIGCHLD, CleanupChild);
    signal(SIGCHLD,SIG_IGN);
    for (int i = 0; i < 100; i++)
    {
        pid_t id = fork();
        if (id == 0)
        {
            // child
            int cnt = 5;
            while (cnt--)
            {
                cout << "I am child process: " << getpid() << endl;
                sleep(1);
            }
            cout << "child process died" << endl;
            exit(0);
        }
    }

    // father
    while (true)
        sleep(1);
}

事实上 , 由于 UNIX 的历史原因 , 要想不产生僵尸进程还有另外一种办法 : 父进程调用 sigaction 将 SIGCHLD 的处理动作置为SIG_IGN, 这样 fork 出来的子进程在终止时会自动清理掉 , 不会产生僵尸进程 , 也不会通知父进程。系统默认的忽略动作和用户用sigaction 函数自定义的忽略通常是没有区别的 , 但这是一个特例。此方法对于 Linux 可用 , 但不保证在其它UNIX 系统上都可用。