Linux进程信号的使用解读_Linux

什么是信号

信号是进程之间事件异步通知的一种方式，属于软中断。

信号的处理能力是进程的内置功能的一部分
进程即便没有收到信号也知道要如何处理信号
当进程收到一个信号时可能不会立刻处理，而是在合适时机处理（按优先级）
一个进程必须当信号产生，到信号开始被处理，就一定会有时间窗口，进程具有保存哪些信号已经发生了的能力。

前后台进程

linux中，一次登录，一个终端一般会配上一个bash，每一次登录，只允许一个进程是前台进程，可以允许多个后台进程

本质区别（前台进程获取键盘输入）

前台进程

./运行后bash不再接受任何指令的进程（bash变为后台），可以用ctrl c二号信号杀掉

后台进程

./proc & 运行（ctrl c不能退出：键盘输入给bash，后台进程接受不到键盘输入），可以用ctrl /杀掉

键盘是如何输入给内核，ctral+c如何变成信号的

键盘也是文件，具有文件缓冲区，操作系统开机后加载到内存里，，即把键盘上数据拷贝到文件缓冲区，再通过接口将文件缓冲区内数据拷贝到用户缓冲区

但是如何知道键盘有数据呢？

键盘可以给cpu发送硬件中断（终端号），操作系统识别到中断号，以中断号为索引到中断表里找方法，再执行。然后将数据发送给cpu寄存器（高低电平）。

信号概念

查看信号

编号34以上的是实时信号

信号是数字，这里是宏定义

信号处理常见方式

可选的处理动作有以下三种:

1. 忽略此信号。
2. 执行该信号的默认处理动作。
3. 提供一个信号处理函数,要求内核在处理该信号时切换到用户态执行这个处理函数,这种方式称为捕捉一个信号。

signal函数

修改特定进程对信号的处理动作
只要设置一次，往后都有效
收到信号才调用handler方式

signum信号编号
handler：谁调用这个signal
typedef void (*sighandler_t)(int);
返回值是void，参数是int的函数指针类型

信号的产生

键盘组合键

ctrl+c (sigint) 已经验证过，这⾥不再重复
ctrl+\（sigquit）可以发送终⽌信号并⽣成core dump⽂件，⽤于事后调试
ctrl+z（sigtstp）可以发送停⽌信号，将当前前台进程挂起到后台等。

kill命令

kill -9 pid即可

系统调用

kill

pid：目标进程的 pid（进程 id）。
sig：要发送的信号（如 sigterm、sigkill 等）。

mykill：

#include <iostream>
#include <string>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

using namespace std;

void usage(string proc)
{
    cout << "usage:\n\t" << proc << " signum pid\n\n";
}

int main(int argc, char *argv[])
{
    
     if(argc != 3)
     {
         usage(argv[0]);
         exit(1);
     }
     int signum = stoi(argv[1]);
     pid_t pid = stoi(argv[2]);

     int n = kill(pid, signum);
     if(n == -1)
     {
         perror("kill");
         exit(2);
     }

    return 0;
}

./mykill 9 进程pid即可

raise

给调用者发送一个制定信号

#include <iostream>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

using namespace std;

void usage(string proc)
{
    cout << "usage:\n\t" << proc << " signum pid\n\n";
}

// mykill signum pid
int main(int argc, char *argv[])
{
    // signal(2, myhandler);
    int cnt = 0;
    while (true)
    {
        cout << "i am a process, pid: " << getpid() << endl;
        sleep(1);
        cnt++;
        if(cnt % 2 == 0) 
        {
            //kill(getpid(), 2);
            raise(2);      
        }
    }
    return 0；
}

abort

引起一个正常信号直接终止（发送6号信号）

#include <iostream>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>

using namespace std;

void usage(string proc)
{
    cout << "usage:\n\t" << proc << " signum pid\n\n";
}

void myhandler(int signo)
{
    cout << "process get a signal: " << signo <<endl;
    // exit(1);
}

// mykill signum pid
int main(int argc, char *argv[])
{
    // signal(2, myhandler);
    
    signal(sigabrt, myhandler);
    int cnt = 0;
    while (true)
    {
        cout << "i am a process, pid: " << getpid() << endl;
        sleep(1);
        cnt++;
        if(cnt % 2 == 0) 
        {
            //kill(getpid(), 2);
            //raise(2);   
            abort();   
        }
    }
    return 0；
}

此时发现即便把abort信号捕捉了仍然会abort退出

但是如果把abort注释，用在终端用kill -6 pid不会终止

总结

无论哪种产生方式，最终一定是操作系统发送给操作系统的，因为操作系统是进程的管理者

异常

硬件

除零错误

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

void handler(int signo)
{
    cout << "...get a sig, number: " << signo <<endl; //我什么都没干，我只是打印了消息
}

int main()
{
    signal(sig_fpe, handler);
    cout<<"div before"<<endl;
    sleep(1);
    int a = 10;
    int b = 0;

    a /= b;
    cout<<"div after"<<endl;
    sleep(1);
    return 0;

}

野指针问题

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

void handler(int signo)
{
    cout << "...get a sig, number: " << signo <<endl; //我什么都没干，我只是打印了消息
}

int main()
{
    signal(sigsegv, handler);
    cout<<"point error before"<<endl;
    sleep(1);
    int *p = nullptr;
    *p = 100;

    cout<<"point error after"<<endl;
    sleep(1);
    return 0;

}

操作系统如何知道错误了呢？

除零错误时：cpu内状态寄存器的溢出标志位被置为1，操作系统会知道（os是硬件的管理者），向进程发送信号，杀死进程。

任何异常只会影响对应进程，不会波及到操作系统

进程出异常与进程是否切换无关，当进程被调度时要把自己进程上下文带走，把别人上下文拿回来（而cpu中状态寄存器输入上下文）

野指针错误时：页表的查询由mmu（硬件内存管理单元）完成，出现异常访问时，页表转换时因权限问题或映射问题转换失败

虚拟到物理地址转换失败，mmu硬件单元报错，将转换失败的虚拟地址放到cpu一个寄存器里

出现异常不崩溃会一直被调度，捕捉信号不是为了解决异常，而是让用户清除为什么挂掉

捕捉信号不是为了解决异常而是让用户清楚为什么进程会挂掉

core dump

当⼀个进程要异常终⽌时,可以选择把进程的⽤户空间内存数据全部保存到磁盘上,⽂件名通常是core,这叫做core dump。

云服务器core默认为0，需要自己修改

示例代码：

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

int main()
{
    // signal(2, sig_ign);
    signal(2, sig_dfl);



    pid_t id = fork();
    if(id == 0)
    {
        //child
        int cnt = 500;
        while(cnt)
        {
            cout << "i am a child process, pid: " << getpid() << "cnt: " << cnt << endl;
            sleep(1);
            cnt--;
        }

        exit(0);
    }

    // father
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid == id)
    {
        cout << "child quit info, rid: " << rid << " exit code: " << 
            ((status>>8)&0xff) << " exit signal: " << (status&0x7f) <<
                " core dump: " << ((status>>7)&1) << endl; // ? & (0000 0000 ... 0001)
    }
    return 0;
}

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

int main()
{
    // signal(2, sig_ign);
    signal(2, sig_dfl);

    while (1)
    {
        cout << "hello signal" << endl;
        sleep(1);
    }

    int a = 10;
    int b = 0;

    a /= b;

    cout << " a = " << a << endl;
    return 0;
}

core dump复现问题错误后直接定位到出错行，方便事后调试。

软件

例如：管道如果只有读没有写就会触发异常

闹钟

闹钟的返回值是闹钟响之后的剩余时间，如果有多个闹钟就返回上个脑中的剩余时间

闹钟响过后默认调用17号信号，但闹钟不是异常，如果进行信号捕捉，里边没有写退出的话，响过后不会终止程序

如果想每隔n秒响一次，就在捕捉后再次设置闹钟即可

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

using namespace std;
void work()
{
    cout << "print log..." << endl;
}

// 信号为什么会一直被触发？？
void handler(int signo)
{
    // work();
    cout << "...get a sig, number: " << signo <<endl; //我什么都没干，我只是打印了消息
    // exit(1);
    int n = alarm(5);
    cout << "剩余时间：" << n << endl;
}

int main()
{
    signal(sigalrm, handler);
    int n = alarm(50);

    while(1)
    {
        cout << "proc is running..., pid: " << getpid() << endl;
        sleep(1);
    }

    sleep(1);

    return 0;
}

信号的保存

信号的发送是给进程的pcb发

task_struct结构体里有int single对象，int32位比特位（普通信号，位图管理信号）

比特位的内容是1还是0表明是否收到

比特位的位置（第几个）表示信号的编号

所谓的发信号，本质就是os去修改task_struct中的信号位图对应的比特位（实质是写信号）

发信号的一定是操作系统，操作系统是进程的管理者，只有os才能修改task_struct内部的属性

信号其他相关常见概念

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

信号从产生到递达之间的状态,称为信号未决。进程可以选择阻塞某个信号。

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

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

在内核中的表示

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

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

3.sigquit信号未产生过,一旦产生sigquit信号将被阻塞,它的处理动作是用户自定义函数sighandler。如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?posix.1允许系统递送该信号一次或多次。linux是这样实现的:常规信号在递达之前产生多次只计一次,而实时信号在递达之前产生多次可以依次放在一个队列里。本章不讨论实时信号。

handler表：

信号的范围[1,31]，每一种信号都要有自己的一种处理方法（系统默认），用户可以通过signal（）函数替换处理方法

pending表：

信号位图，记录是否收到信号及哪些信号

block表：

用来记录某种信号是否被屏蔽
对一个特定任务可以屏蔽，能够接受到但是不会执行，想做了就解除屏蔽
屏蔽是一种状态，和现在收到信号没有无关
信号没有产生也能被屏蔽

阻塞（屏蔽）和忽略

阻塞/屏蔽（未读）：屏蔽掉信号，阻止其立即递达，但信号会被记录在未决集中，待解除阻塞后处理。
忽略（拒收）：不会递达，处理信号（信号抵达三种方式之一），明确丢弃信号，内核直接删除该信号，不会递达也不会记录

sig_ign忽略
sig_ign将1强转成函数指针类型
sig_dfl使用信号默认方式

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

int main()
{
    // signal(2, sig_ign);
    signal(2, sig_dfl);

    while(1)
    {
        cout << "hello signal" << endl;
        sleep(1);
    }
    return 0;
}

sigset_t（数据类型）

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

sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。阻塞信号集也叫做当前进程的信号屏蔽字

这里的“屏蔽”应该理解为阻塞而不是忽略。

信号集操作函数

信号集是系统提供的一种数据类型，方便我们未来对pending表和block表做操作

sigset_t类型对于每种信号用一个bit表示“有效”或“无效”状态,至于这个类型内部如何存储这些bit则依赖于系统实现,从使用者的角度是不必关心的,使用者只能调用以下函数来操作sigset_ t变量,而不应该对它的内部数据做任何解释,比如用printf直接打印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);

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

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

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

4.这四个函数都是成功返回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参数的可选值。

sig_block：新增屏蔽信号（或运算有1为1）
sig_unblock：在进程block表里去掉传入的set信号
sig_setmask：直接设置进进程pcb的block表里，覆盖式的设置全新屏蔽字段

sigset_t *oset：输出型参数，将上一个block表进行保存（为了未来恢复）

sigpending

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

set输出型参数：把pending表以位图形式带出来

示例代码：

#include <iostream>
#include <unistd.h>
#include <signal.h>

using namespace std;

void printpending(sigset_t &pending)
{
    for (int signo = 31; signo >= 1; signo--)
    {
        if (sigismember(&pending, signo))
        {
            cout << "1";
        }
        else
        {
            cout << "0";
        }
    }
    cout << "\n\n";
}

void handler(int signo)
{
    cout << "catch a signo: " << signo << endl;
}

int main()
{
    // 0. 对2号信号进行自定义捕捉
    signal(2, handler);

    // 1. 先对2号信号进行屏蔽 --- 数据预备
    sigset_t bset, oset; // 在哪里开辟的空间？？？用户栈上的，属于用户区
    sigemptyset(&bset);
    sigemptyset(&oset);
    sigaddset(&bset, 2); // 我们已经把2好信号屏蔽了吗？并没有设置进入到你的进程的task_struct
    // 1.2 调用系统调用，将数据设置进内核
    sigprocmask(sig_setmask, &bset, &oset); // 我们已经把2好信号屏蔽了吗？ok

    // 2. 重复打印当前进程的pending 0000000000000000000000000
    sigset_t pending;
    int cnt = 0;
    while (true)
    {
        // 2.1 获取
        int n = sigpending(&pending);
        if (n < 0)
            continue;
        // 2.2 打印
        printpending(pending);

        sleep(1);
        cnt++;
        // 2.3 解除阻塞
        if(cnt == 20)
        {
            cout << "unblock 2 signo" << endl;
            sigprocmask(sig_setmask, &oset, nullptr); // 我们已经把2好信号屏蔽了吗？ok
        }
    }
    // 3 发送2号 0000000000000000000000010

    return 0;
}

9号和19号新号不可以被捕捉和屏蔽（演示代码）

#include <iostream>
#include <unistd.h>
#include <signal.h>

using namespace std;

void printpending(sigset_t &pending)
{
    for (int signo = 31; signo >= 1; signo--)
    {
        if (sigismember(&pending, signo))
        {
            cout << "1";
        }
        else
        {
            cout << "0";
        }
    }
    cout << "\n\n";
}

void handler(int signo)
{
    cout << "catch a signo: " << signo << endl;
}

int main()
{
    // 4. 我可以将所有的信号都进行屏蔽，信号不就不会被处理了吗？ 肯定的！9
    sigset_t bset, oset;
    sigemptyset(&bset);
    sigemptyset(&oset);
    for (int i = 1; i <= 31; i++)
    {
        sigaddset(&bset, i); // 屏蔽了所有信号吗？？？
    }
    sigprocmask(sig_setmask, &bset, &oset);

    sigset_t pending;
    while (true)
    {
        // 2.1 获取
        int n = sigpending(&pending);
        if (n < 0)
            continue;
        // 2.2 打印
        printpending(pending);
        sleep(1);
    }
    return 0;
}

信号处理

信号是什么时候被处理的

当进程从内核态返回到用户态时进行对信号的检测和处理
调用系统调用时——操作系统会自动做身份切换，用户身份变成内核身份（或者反着来）
由cpu中esc寄存器决定：当esc寄存器低两位为11时为用户态，为00时为内核态
int 80 从用户态陷入内核态的一条汇编，将11改为00

刚开机操作系统就加载了，所以在物理内存较靠下的位置，进程pcb的3——4g空间是内核空间，由内核级页表映射到物理内存，内核级页表只有一个（所有进程都可以看到），用户级页表好几个（进程具有独立性）。

进程视角：调用系统中的方法时，就是在自己的地址空间中进行的（类似于共享区与代码段之间的跳转）。

操作系统视角：任何一个时刻，都是有进程执行的，我们想执行操作系统的代码就可以执行。

操作系统的本质是一个死循环。

操作系统的运行是被动的，由时钟来推动进行，当时钟信号来时，停止运行当前进程代码，去查看进程的调度，只要进程在跑，cpu就会调度进程，只要调度，时间片就会被消耗完毕，消耗完后把进程从cpu上剥离下来。（下次调度将pcb等汇总到cpu上（内核态））

操作系统不相信用户还体现在不会执行用户的代码（要执行代码必须从内核态跳转到用户态）

没用调用系统调用的代码也会有内核态和用户态的切换（二次调用时）上边红字

信号捕捉

内核如何实现信号的捕捉

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

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

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

实现信号捕捉代码

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <signal.h>

using namespace std;

void handler(int signo)
{
    cout<< "catch a signal, signal number : " << signo << endl;
}

int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));
    
    act.sa_handler = handler;

    sigaction(2,&act,&oact);

    while (true)
    {
        cout << "i am a process: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

pending位图，什么时候从1->0

当进行信号处理时，倘若已经进入到了信号的捕捉代码里，先把信号位图由1清零，才调用handler方法

执行信号捕捉方法之前，先清0，在调用

演示代码

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <signal.h>

using namespace std;

void printpending()
{
    sigset_t set;
    sigpending(&set);

    for (int signo = 1; signo <= 31; signo++)
    {
        if (sigismember(&set, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << "\n";
}

void handler(int signo)
{
    printpending();
    sleep(1);
}

int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));
    
    act.sa_handler = handler;

    sigaction(2,&act,&oact);

    while (true)
    {
        cout << "i am a process: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

当某个信号的处理函数被调用时

内核自动将当前信号加入进程的信号屏蔽字

信号被处理的时候，对应的信号也会被添加到block表中，防止信号捕捉被嵌套调用

操作系统不允许对同一种信号进行嵌套式的捕捉（如果没有屏蔽会导致在处理时调用handler函数）

当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么它会被阻塞到当前处理结束为止。

演示代码

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <signal.h>

using namespace std;

void printpending()
{
    sigset_t set;
    sigpending(&set);

    for (int signo = 1; signo <= 31; signo++)
    {
        if (sigismember(&set, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << "\n";
}

void handler(int signo)
{
    cout << "catch a signal, signal number : " << signo << endl;
    while (true)
    {
        printpending();
        sleep(1);
    }
}

int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));
    
    act.__sigaction_handler = handler;

    sigaction(2,&act,&oact);

    while (true)
    {
        cout << "i am a process: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

如果在调用信号处理函数时

除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号

用sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字。
sa_ﬂags字段包含一些选项,本章的代码都把sa_ﬂags设为0,sa_sigaction是实时信号的处理函数

示例代码

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <signal.h>

using namespace std;

void printpending()
{
    sigset_t set;
    sigpending(&set);

    for (int signo = 1; signo <= 31; signo++)
    {
        if (sigismember(&set, signo))
            cout << "1";
        else
            cout << "0";
    }
    cout << "\n";
}

void handler(int signo)
{
    cout << "catch a signal, signal number : " << signo << endl;
    while (true)
    {
        printpending();
        sleep(1);
    }
}

int main()
{
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));
    
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask, 1);
    sigaddset(&act.sa_mask, 3);
    sigaddset(&act.sa_mask, 4);

    act.__sigaction_handler = handler;

    sigaction(2, &act, &oact);

    while (true)
    {
        cout << "i am a process: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

可重入函数

会导致节点丢失，内存泄漏问题

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

像上例这样,insert函数被不同的控制流程调用,有可能在第一次调用还没返回时就再次进入该函数,这称为重入,insert函数访问一个全局链表,有可能因为重入而造成错乱,像这样的函数称为不可重入函数,反之, 如果一个函数只访问自己的局部变量或参数,则称为可重入(reentrant) 函数。想一下,为什么两个不同的控制流程调用同一个函数,访问它的同一个局部变量或参数就不会造成错乱?

如果一个函数符合以下条件之一则是不可重入的:

调用了malloc或free,因为malloc也是用全局链表来管理堆的。

调用了标准i/o库函数。标准i/o库的很多实现都以不可重入的方式使用全局数据结构。

volatile

volatile防止编译器过度优化，保存内存可见性（保证每次都从内存读取）
逻辑反也是一种计算
在优化条件下，flag在cpu内执行，在内存修改不会影响到寄存器

makefile

mysignal:mysignal.cc
	g++ -o $@ $^ -o3 -g -std=c++11
.phony:clean
clean:
	rm -f mysignal

#include <iostream>
#include <cstring>
#include <unistd.h>
#include <signal.h>

using namespace std;

volatile int flag = 0;

void handler(int signo)
{
    cout << "catch a signal: " << signo << endl;
    flag = 1;
}

int main()
{
    signal(2, handler);
    // 在优化条件下， flag变量可能被直接优化到cpu内的寄存器中
    while(!flag); // flag 0, !falg 真

    cout << "process quit normal" << endl;
    return 0;
}

sigchld信号

子进程退出时主动向父进程发送sigchld（17）信号

#include <iostream>
#include <cstdlib>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
 
void handler(int signo)
{
     void handler(int signo)
 {
     sleep(5);
     pid_t rid;
     while ((rid = waitpid(-1, nullptr, wnohang)) > 0)
     {
         cout << "i am proccess: " << getpid() << " catch a signo: " << signo << "child             
          process quit: " << rid << endl;
     }
 }
}
 
// 验证子进程退出，给父进程发送sigchld
int main()
{
    signal(sigchld, handler);
    // 问题1: 1个子进程，10个呢？
    // 问题2: 10个子进程，6个退出了！
    for (int i = 0; i < 10; i++)
    {
        if (fork() == 0)
        {
            sleep(5);
            std::cout << "子进程退出" << std::endl;
            // 子进程
            exit(0);
        }
    }
 
    while (true)
    {
        sleep(1);
    }
    return 0;
}

如果不用知道子进程退出结构直接这样即可。

int main()
{
    signal(sigchld, handler);
    // 问题1: 1个子进程，10个呢？
    // 问题2: 10个子进程，6个退出了！
    for (int i = 0; i < 10; i++)
    {
        if (fork() == 0)
        {
            sleep(5);
            std::cout << "子进程退出" << std::endl;
            // 子进程
            exit(0);
        }
    }
 
    while (true)
    {
        sleep(1);
    }
    return 0;
}

17号信号默认sig_dfl他的默认行为是ign，所以仍旧会有僵尸进程

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持代码网。


验证码：

Linux进程信号的使用解读

2025年06月25日 • Linux •我要评论

什么是信号

前后台进程

前台进程

后台进程

键盘是如何输入给内核，ctral+c如何变成信号的

信号概念

查看信号

信号处理常见方式

signal函数

信号的产生

键盘组合键

kill命令

系统调用

kill

mykill：

raise

abort

总结

异常

硬件

除零错误

野指针问题

core dump

示例代码：

软件

信号的保存

信号其他相关常见概念

在内核中的表示

handler表：

pending表：

block表：

阻塞（屏蔽）和忽略

sigset_t（数据类型）

信号集操作函数

sigprocmask

sigpending

示例代码：

信号处理

信号是什么时候被处理的

信号捕捉

内核如何实现信号的捕捉

实现信号捕捉代码

pending位图，什么时候从1->0

演示代码

当某个信号的处理函数被调用时

演示代码

如果在调用信号处理函数时

示例代码

可重入函数

volatile

sigchld信号

总结

相关文章:

Nginx报错403问题排查与解决办法

Linux下的进程地址空间详解

检查Linux中磁盘使用情况的四种方法

发表评论