linux进程信号

最新推荐文章于 2024-10-01 22:54:40 发布

Artiel

最新推荐文章于 2024-10-01 22:54:40 发布

阅读量1k

点赞数 16

分类专栏： Linux 文章标签： linux

本文链接：https://blog.csdn.net/weixin_73142957/article/details/136355460

版权

Linux 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

信号的概念

生活角度的信号：

在日常生活中，信号可能是这样的：红绿灯，下课铃声，脸色，电话铃声等

以红绿灯为例：我们为什么认识红绿灯（我们能够识别红绿灯，知道对应的灯亮，意味着什么，要做什么），这是因为有人提前告诉过我们

由此：

信号没有产生的时候，其实我们已经能够知道怎么处理这个信号了

信号的到来，我们并不清楚具体什么时候，信号到来对于我正在做的工作，是异步产生的

异步的概念我们可以简单理解为：你在吃饭，你的朋友在散步，各自干各自的事情

信号产生了，我们不一定要立即处理它，而是我们在合适的时候处理-->我要有一种能力，将已经到来的信号，进行暂时保存

以上的主角（我们/我）是进程

技术应用角度的信号：用户输入命令,在Shell下启动一个前台进程，用户按下Ctrl-C ,这个键盘输入产生一个硬件中断，被OS获取，解释成信号，发送给目标前台进程 . 前台进程因为收到信号，进而引起进程退出

什么叫做信号：

信号是一种向目标进程发送通知消息的一种机制

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

注意

1. Ctrl-C 产生的信号只能发给前台进程。一个命令后面加个&可以将前台进程放到后台运行,这样Shell不必等待进程结束就可以接受新的命令,启动新的进程。

2. Shell可以同时运行一个前台进程和任意多个后台进程,只有前台进程才能接到像 Ctrl-C 这种控制键产生的信号。

3.前台进程在运行过程中用户随时可能按下 Ctrl-C 而产生一个信号,也就是说该进程的用户空间代码执行到任何地方都有可能收到 SIGINT 信号而终止,所以信号相对于进程的控制流程来说是异步的

用kill -l命令可以查看系统定义的信号列表

每个信号都有一个编号和一个宏定义名称

编号34以上的是实时信号，本篇只讨论编号34以下的信号,不讨论实时信号。

这些信号各自在什么条件下产生,默认的处理动作是什么,在signal(7)中都有详细说明: man 7 signal

信号处理常见方式概览

1. 忽略此信号

2. 执行该信号的默认处理动作

3. 提供一个信号处理函数,要求内核在处理该信号时切换到用户态执行这个处理函数,这种方式称为捕捉 (Catch)一个信号

信号的产生

预备了解

process.cc

int main()
{
    while(true)
    {
        std::cout<<"running...."<<std::endl;
        sleep(1);
    }
    return 0;
}

在后台运行的进程可以通过kill -9 进程id名来杀掉进程

进程在运行的时候，前台（命令行操作的时候，只能有一个）后台（./xxx &）（可以有多个）

指令jobs可以用来查看后台任务

把后台进程提到前台，可以使用fg 任务编码

区分前台进程还是后台进程，就看有没有能力接收用户输入

ctrl+c：终止前台进程（一般情况）

OS会自动把shell提到前台或者后台

前台进程永远不能被暂停（ctrl+z）如果被暂停，该前台进程必须立即被放到后台

命令总结：

把进程放置后台运行：./xxx &

查看后台任务：jobs

把后台进程提到前台：fg number（任务编号）

前台任务转到后台：ctrl+z，bg number

下一个问题：OS怎么知道键盘有数据输入了？

外设是可以间接地向CPU特定的针脚发送就绪信息的，特定针脚所对应的编号称之为中断号

有了中断号，那么哪些外设准备就绪了，操作系统是能够立马知道的

外设一旦准备就绪，操作系统会把手头工作放下，根据读取到的中断号去映射特定硬件的读取方法，然后执行，这样操作系统就不用关心外设了，因为只要外设准备好，它会自动通知操作系统

上图所示表为中断向量表，是操作系统启动开机的时候帮我们创建的第一张表

信号本质其实就是用软件来模拟中断行为

上面介绍的用于终止前台进程的ctrl+c 等价于发送2号型号 kill -2

信号在合适的时候进行处理：

1 默认行为

2 忽略

3 自定义---信号的捕捉

signal方法：对特定的信号将其默认行为，修改成自定义行为，只要修改一次，就永久有效

注意：9号信号不可被自定义捕捉

void handler(int signo)
{
    std::cout << "获得一个2号信号" << std::endl;
    exit(1);
}

int main()
{
    signal(2, handler);//收到2号信号后，不是终止进程而是去执行handler方法

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

信号的产生

1. 通过终端按键产生信号

SIGINT的默认处理动作是终止进程,SIGQUIT的默认处理动作是终止进程并且Core Dump

Core Dump

首先解释什么是Core Dump。当一个进程要异常终止时,可以选择把进程的用户空间内存数据全部保存到磁盘上,文件名通常是core,这叫做Core Dump。进程异常终止通常是因为有Bug,比如非法内存访问导致段错误, 事后可以用调试器检查core文件以查清错误原因,这叫做Post-mortem Debug（事后调试）。一个进程允许产生多大的core文件取决于进程的Resource Limit(这个信息保存在PCB中)。默认是不允许产生core文件的, 因为core文件中可能包含用户密码等敏感信息,不安全。在开发调试阶段可以用ulimit命令改变这个限制,允许产生core文件。首先用ulimit命令改变Shell进程的Resource Limit,允许core文件最大为1024K: $ ulimit -c 1024

可以通过键盘进行信号的产生，譬如ctrl+c，就是向前台进程发送2号信号，ctrl+z，即默认暂停进程，ctrl+\，即默认终止进程

理解：键盘按下ctrl+c，操作系统会知道键盘中有数据并读取，然后对该数据进行判断，如果是普通字符就交给进程，如果是控制字符（组合键）就直接解释成为命令，即向目标进程发送信号

进程根据收到的2号信号去表中找对应处理行为，将自己直接干掉了

每一个进程都有一张属于自己的函数指针数组表，数组的下标就和信号的编号强相关

对于普通信号来讲，进程收到信号之后，进程要表示自己是否收到了某种信号，进程可能会收到多种信号，所以进程要对收到的信号管理起来，故而在进程的PCB内要维护一张位图：比特位的位置，决定信号编号，比特位的内容，决定是否收到信号

OS向目标进程发送信号，即写信号，其实就是找到进程的PCB，将其中位图特定比特位上的内容由0置1

无论信号有多少种产生方式，永远只能让OS向目标进程发送，因为OS是进程的管理者

查看信号的默认处理动作：man 7 signal

2. 调用系统函数向进程发信号

通过系统调用产生信号

kill命令是调用kill函数实现的。kill函数可以给一个指定的进程发送指定的信号。raise函数可以给当前进程发送指定的信号(自己给自己发信号)

#include <signal.h>
int kill(pid_t pid, int signo);
int raise(int signo);
这两个函数都是成功返回0,错误返回-1。

abort函数使当前进程接收到信号而异常终止

#include <stdlib.h>
void abort(void);
就像exit函数一样,abort函数总是会成功的,所以没有返回值。

kill

kill系统调用接口：向任意指定进程发送任意指定信号

一段简单模拟kill的代码

process.cc

static void Usage(const std::string &proc)
{
    std::cout << "\nUsage: " << proc << " -signumber process\n" << std::endl;
}


int main(int argc, char *argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        exit(0);
    }

    int signumber = std::stoi(argv[1]+1);
    int processpid = std::stoi(argv[2]);

    kill(processpid, signumber);
    return 0;
}

mytest.c

int main()
{
    while(1)
    {
        printf("I am a process, pid: %d\n", getpid());
        sleep(1);
    }
}

Makefile

process:process.cc
	g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
	rm -f process

将process程序改名为mykill

raise

给自己发送指定信号

简单代码演示：

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

int main()
{
    signal(2,handler);//对2号信号自定义捕捉，将其对应的默认处理行为修改为自定义行为
    while(1)
    {
        raise(2);//向自己发送2号信号
        sleep(1);
    }
    return 0;
}

abort

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

int main()
{
    signal(SIGABRT,handler);//虽然自定义捕捉了，但是调用abort依然终止进程，后面代码不会继续运行
    abort();

    while(1)
    {
        std::cout<<"I am running "<<std::endl;
        sleep(1);
    }
    return 0;
}

3.. 硬件异常产生信号

硬件异常被硬件以某种方式被硬件检测到并通知内核,然后内核向当前进程发送适当的信号。例如当前进程执行了除以0的指令,CPU的运算单元会产生异常,内核将这个异常解释为SIGFPE信号发送给进程。再比如当前进程访问了非法内存地址,,MMU会产生异常,内核将这个异常解释为SIGSEGV信号发送给进程

异常

除0以后终止进程：因为程序运行起来就成为一个进程，除0之后，CPU内的状态寄存器的溢出标记位由0置1，表示计算结果出现异常,CPU内部出现错误，直接通知OS，那么OS就要向引发该错误的进程发送信号，从而导致该进程终止

把进程杀掉，默认就是处理问题的方式之一

int main()
{
    int a = 10;
    a/=0;
    return 0;
}

void handler(int signo)
{
    std::cout<<"get a signo : "<<signo<<std::endl;
    sleep(1);
    //注意，此时没有exit()退出
}

int main()
{
    signal(8,handler);//为了验证：自定义捕捉8号信号
    int a = 10;
    a/=0;
    return 0;
}

原因：

寄存器！=寄存器里的内容，寄存器里的内容是进程的上下文数据，原本出现异常，进程会被杀掉，那么状态寄存器中的溢出标记位的内容就可以被其他进程覆盖，而且进程被杀掉也就永远不会被CPU调度

我们现在将8号信号的默认处理方式：杀掉进程，改为自定义行为了，即不再终止进程了，也就是该进程收到8号信号不再退出，可是除0的异常一直存在，所以CPU只要调度该进程，就会告知OS，它内部出现错误，那么OS就会去处理，处理方式为：打印一句话，但是处理完成后，该进程依然没被杀掉，它还在被调度，只要被调度，该进程的上下文数据就会恢复到CPU内的寄存器中，那么状态寄存器中的溢出标记位的内容还是1，CPU就还要告知OS，OS的处理方式还是打印一句话，如此循环......

本质来讲，就是该进程除0错误出现异常却没有终止，一直在被CPU调度

解决方式：一旦出现异常，直接终止进程

void handler(int signo)
{
    std::cout<<"get a signo : "<<signo<<std::endl;
    sleep(1);
    exit(0);
}

int main()
{
    signal(8,handler);//为了验证：自定义捕捉8号信号
    int a = 10;
    a/=0;
    return 0;
}

野指针问题：

    int*p = nullptr;
    *p = 100;

p是指针变量，保存的是0号地址，*p=100，向0号地址处写入100，但是在当前进程的页表当中，并没有建立从0号地址到对应物理地址的映射关系，转化工作失败，CPU内部存在一个硬件单元，叫做MMU（内存管理单元），转化工作不仅仅由页表完成，还有MMU的参与（通过给到的虚拟地址，找到对应的物理地址）CPU内部使用的地址基本就是虚拟地址，CPU内本身有一个寄存器指向当前进程对应的页表，而MMU则负责完成虚拟地址到物理地址的转化，如果转化失败，MMU则会报错，出现硬件问题，MMU出现问题，OS识别到硬件问题，就把引起该问题的进程直接杀掉

简单来说，野指针问题就是虚拟地址到物理地址的转化出错，出现了硬件问题，OS识别到后，直接向目标进程写信号

总之：产生信号的方式可以有很多，但是发送信号只能由OS发送

4. 由软件条件产生信号

#include <unistd.h>
unsigned int alarm(unsigned int seconds);
调用alarm函数可以设定一个闹钟,也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号, 该信号的默认处理动
作是终止当前进程。

这个函数的返回值是0或者是以前设定的闹钟时间还余下的秒数

如果seconds值为0,表示取消以前设定的闹钟,函数的返回值仍然是以前设定的闹钟时间还余下的秒数

闹钟就是一种软件条件

返回值是闹钟剩余时间

int cnt = 0;
int n = 0;

void handler(int signo)
{
    n = alarm(0);
    cout<<"result: "<<n<<endl;//获取闹钟的剩余时间
    exit(0);
}

int main()
{
    signal(14,handler);
    cout << "pid: " << getpid() << endl;
    alarm(1);
    while(true)
    {
        sleep(1);
    }
    return 0;
}

闹钟到点了会发送14号信号

可以提前发送信号来让闹钟提前结束

将闹钟设置为30秒

int cnt = 0;
int n = 0;

void handler(int signo)
{
    n = alarm(0);
    cout<<"result: "<<n<<endl;//获取闹钟的剩余时间
    exit(0);
}

int main()
{
    signal(14,handler);
    cout << "pid: " << getpid() << endl;
    alarm(30);
    while(true)
    {
        sleep(1);
    }
    return 0;
}

闹钟重复响：

int n = 0;

void handler(int signo)
{
    alarm(2);
    cout<<"result: "<<n<<endl;//获取闹钟的剩余时间
}

int main()
{
    signal(14,handler);
    cout << "pid: " << getpid() << endl;
    alarm(2);
    while(true)
    {
        sleep(1);
        cout<<"running...."<<endl;
    }
    return 0;
}

所有用户的行为都是以进程的形式在OS中表现的，操作系统只要把进程调度好就能完成所有的用户任务

CMOS，周期性的，高频率的向CPU发送时钟中断

朴素的对OS进行理解：操作系统本质就是一个死循环

test_signal.cc

int main()
{
    cout<<"getpid : "<<getpid()<<endl;
    int a = 10;
    a /= 0;
    return 0;
}

Makefile

test_signal:test_signal.cc
	g++ -o $@ $^ -std=c++11 -g
.PHONY:clean
clean:
	rm -f test_signal

查看系统中基本的配置项：ulimit -a

int main()
{
    cout<<"getpid : "<<getpid()<<endl;
    cout<<"getpid : "<<getpid()<<endl;
    cout<<"getpid : "<<getpid()<<endl;

    int a = 10;
    a /= 0;

    cout<<"getpid : "<<getpid()<<endl;
    cout<<"getpid : "<<getpid()<<endl;
    cout<<"getpid : "<<getpid()<<endl;
    cout<<"getpid : "<<getpid()<<endl;
    cout<<"getpid : "<<getpid()<<endl;

    return 0;
}

信号的处理动作一般有以下三种：

信号的默认（搭配SIG_DFL）、信号的忽略（搭配SIG_IGN）、信号的自定义捕捉

void handler(int signo)
{
    cout<<"handler "<<signo<<endl;
}
int main()
{
    cout<<"getpid : "<<getpid()<<endl;
    signal(2,handler);//2号信号自定义捕捉
    sleep(10);
    signal(2,SIG_DFL);//将2号信号的处理方式恢复成默认
    cout<<"getpid : "<<getpid()<<endl;
    cout<<"getpid : "<<getpid()<<endl;

    while(true)
    {
        sleep(1);
    }

    return 0;
}

void handler(int signo)
{
    cout<<"handler "<<signo<<endl;
}
int main()
{
    cout<<"getpid : "<<getpid()<<endl;
    signal(2,handler);//2号信号自定义捕捉
    sleep(10);
    signal(2,SIG_IGN);//信号的忽略
    cout<<"getpid : "<<getpid()<<endl;
    cout<<"getpid : "<<getpid()<<endl;

    while(true)
    {
        sleep(1);
    }

    return 0;
}

信号其他相关常见概念

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

信号从产生到递达之间的状态,称为信号未决(Pending)

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

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

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

信号未决：

信号产生的时候，进程可能在做着更为重要的事情，不能立即处理信号，就要求进程要有对信号进行保存的能力，采用位图来保存信号，保存在信号位图中，就叫做信号未决

进程可以选择阻塞某个信号：未决之后，暂时不递达，直到解除对信号的阻塞

信号在内核中的表示示意图

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

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

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

sigset_t

从上图来看,每个信号只有一个bit的未决标志,非0即1,不记录该信号产生了多少次,阻塞标志也是这样表示的。因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储,sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态

阻塞信号集也叫做当前进程的信号屏蔽字(Signal Mask),这里的“屏蔽”应该理解为阻塞而不是忽略

信号集操作函数

#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>

       int sigpending(sigset_t *set);

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

屏蔽

void handler(int signo)
{
    cout<<"handler "<<signo<<endl;
}
int main()
{
    cout<<"getpid : "<<getpid()<<endl;
    signal(2,handler);

    sigset_t block,oblock;
    sigemptyset(&block);
    sigemptyset(&oblock);

    sigaddset(&block,2);//这里还没有对2号信号设置屏蔽
    sigprocmask(SIG_BLOCK,&block,&oblock);//进程原来的block表内容记录在oblock里（真正将2号信号屏蔽）

    while(true)
    {
        sleep(1);
    }

    return 0;
}

最后按下ctrl+\退出

void handler(int signo)
{
    cout<<"handler "<<signo<<endl;
}
int main()
{
    cout<<"getpid : "<<getpid()<<endl;
    signal(2,handler);

    sigset_t block,oblock;
    sigemptyset(&block);
    sigemptyset(&oblock);

    for(int signo = 1;signo<=31;signo++)//普通信号共有31个
    {
        sigaddset(&block,signo);
    }

  
    sigprocmask(SIG_SETMASK,&block,&oblock);//进程原来的block表内容记录在oblock里（真正将2号信号屏蔽）

    while(true)
    {
        cout<<"已屏蔽所有信号！"<<endl;
        sleep(1);
    }

    return 0;
}

屏蔽信号-->解除信号屏蔽

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

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


int main()
{
    signal(2, handler);
    cout<<"getpid : "<<getpid()<<endl;
    //1. 屏蔽2号信号
    sigset_t set, oset;
    sigemptyset(&set);
    sigemptyset(&oset);
    sigaddset(&set, 2);
    sigprocmask(SIG_BLOCK, &set, &oset);

    // 2. 让进程不断获取当前进程的pending
    int cnt = 0;
    sigset_t pending;
    while(true)
    {
        sigpending(&pending);
        PrintPending(pending);

        sleep(1);

        cnt++;

        if(cnt == 5)
        {
            cout << "解除对2号信号的屏蔽, 2号信号准备递达" <<endl;
            sigprocmask(SIG_SETMASK, &oset, nullptr);
        }
    }
    return 0;
}

信号的处理

信号在合适的时候被处理-->即进程从内核态返回到用户态的时候，进行信号的检测和信号的处理

（如果信号没有被阻塞，且处理方式为自定义捕捉，那么就要由内核态切换到用户态去执行用户自己写的自定义捕捉代码，代码执行完成后，通过sigreturn重新切回内核态，最后再由内核态返回到用户态，去执行用户层剩余的代码，整个流程抽象为无穷大符号）

捕捉信号

如果信号的处理动作是用户自定义函数,在信号递达时就调用这个函数,这称为捕捉信号。由于信号处理函数的代码是在用户空间的,处理过程比较复杂,举例如下: 用户程序注册了SIGQUIT信号的处理函数sighandler。当前正在执行 main函数,这时发生中断或异常切换到内核态。在中断处理完毕后要返回用户态的main函数之前检查到有信号 SIGQUIT递达。内核决定返回用户态后不是恢复main函数的上下文继续执行,而是执行sighandler函数,sighandler 和main函数使用不同的堆栈空间,它们之间不存在调用和被调用的关系,是两个独立的控制流程。 sighandler函数返回后自动执行特殊的系统调用sigreturn再次进入内核态。如果没有新的信号要递达,这次再返回用户态就是恢复 main函数的上下文继续执行了。

用户态是一种受控的状态，能够访问的资源是有限的

内核态是一种操作系统的工作状态，能够访问大部分系统资源（系统调用背后，就包含了身份的变化）

OS中，内核页表只要一份就够了

就如同库函数的调用一样，调用系统调用接口也是在进程的地址空间中进行的

用户态：只能访问自己的[0,3GB]，内核态：可以让用户以OS的身份访问[3,4GB]

无论进程如何调度，CPU都可以直接找到OS

我们进程所有代码的执行，都可以在自己的进程地址空间内通过跳转的方式，进行调用和返回

在CPU内有一个叫做CS的寄存器，其中有两个比特位可以用来标识当前为用户态还是内核态，

为1表示内核态，为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参数,通过参数可以得知当前信号的编号

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

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


int main()
{
    struct sigaction act, oact;
    act.sa_handler = handler;

    sigaction(2,&act,&oact);
    while(true) 
    {
        sleep(1);
    }
    return 0;
}

void Print(const sigset_t &pending)
{
   for(int signo = 31; signo > 0; signo--)
   {
       if(sigismember(&pending, signo))//判断指定信号是否在目标集合中
       {
           cout << "1";
       }
       else
       {
           cout << "0";
       }
   }
   cout << endl;
}

void handler(int signo)
{
    cout<<"get a sig "<<signo<<endl;
    while(true)
    {
        sigset_t pending;
        sigpending(&pending);//获取未决信号集
        Print(pending);
        sleep(1);
    }
}


int main()
{
    cout<<"pid: "<<getpid()<<endl;
    struct sigaction act, oact;
    act.sa_handler = handler;

    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask,3);//将3号信号阻塞屏蔽
    sigaction(2,&act,&oact);//设置2号信号的自定义处理方式

    while(true) 
    {
        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

int flag = 0;

void handler(int signo)
{
   cout << "signo: " << signo <<endl;
   flag = 1;
   cout << "change flag to: " << flag <<endl;
}

int main()
{
   signal(2, handler);
   cout << "getpid: " << getpid() << endl;
   while(!flag);
   cout << "quit normal!" << endl;
}

标准情况下，输入CTRL-C ,2号信号被捕捉，执行自定义动作，修改 flag＝1 ， while 条件不满足,退出循环，进程退出

编译器通常会做优化：

Makefile

testSig:testSig.cc
	g++ -o $@ $^ -O1 -std=c++11//-01为优化选项
.PHONY:clean
clean:
	rm -f testSig

优化情况下，键入 CTRL-C ,2号信号被捕捉，执行自定义动作，修改 flag＝1 ，但是 while 条件依旧满足,进程继续运行！但是很明显ﬂag肯定已经被修改了，但是为何循环依旧执行？

因为：while循环检查的ﬂag，并不是内存中最新的ﬂag，while 检测的ﬂag其实已经因为优化，被放在了CPU寄存器当中，解决方法是使用volatile

加上volatile：保持内存可见性

volatile 作用：保持内存的可见性，告知编译器，被该关键字修饰的变量，不允许被优化，对该变量的任何操作，都必须在真实的内存中进行操作

volatile int flag = 0;

void handler(int signo)
{
   cout << "signo: " << signo <<endl;
   flag = 1;
   cout << "change flag to: " << flag <<endl;
}

int main()
{
   signal(2, handler);
   cout << "getpid: " << getpid() << endl;
   while(!flag);
   cout << "quit normal!" << endl;
   return 0;
}

SIGCHLD信号

再来一个问题：子进程退出的时候，是什么都没说吗？

答案：不是，子进程在退出的时候是要给父进程发送信号的（SIGCHLD)

验证：

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

int main()
{
   signal(SIGCHLD, handler);
   pid_t id = fork();
   if(id==0)
   {
        cout<<"child is running"<<endl;
        sleep(5);
        exit(10);
   }

   int cnt = 10;
   while(cnt--)
   {
        cout<<"cnt: "<<cnt<<endl;
        sleep(1);
   }
   wait(NULL);
   return 0;
}

基于信号的方式回收子进程：

void handler(int signo)//父进程会收到子进程发送的信号，进行相应处理，故而可以在自定义捕捉时回收子进程
{
   cout << "get a signo: " << signo <<endl;
   pid_t id = 0;
   //设置成非阻塞式等待：如果子进程不是全部退出，而是6个退出，4个不退出
   //若还是设置成阻塞式等待，在while循环回收完6个子进程后，依然进行第7次等待，此时没有进程退出，waitpid也就不返回，父进程无法继续执行
   //故而需要设成WNOHANG（非阻塞式等待）这样进程不退出，waitpid立即返回0，父进程可以继续执行
   while(id = waitpid(-1,nullptr,WNOHANG))//可能有多个子进程同时退出的情况，都会发送信号，但不是所有子进程同一时间退出时发送的同一信号都会被保存（会有遗漏），所以需要while循环确保回收所有退出子进程
   {
        if(id<=0) break;
        cout<<"回收进程: "<<id<<endl;
   }
}

int main()
{
   signal(SIGCHLD, handler);
   for(int i = 0;i<10;i++)
   {
        pid_t id = fork();
        if(id==0)
        {
            cout<<"child is running"<<endl;
            sleep(5);
            exit(10);
        }
   }

   while(true) sleep(1);
   return 0;
}

Linux支持手动忽略SIGCHLD，忽略之后的效果：所有的子进程都不用父进程进行等待了，子进程退出系统自动回收

int main()
{
   signal(SIGCHLD, SIG_IGN);//手动忽略SIGCHLD
   for(int i = 0;i<10;i++)
   {
        pid_t id = fork();
        if(id==0)
        {
            cout<<"child is running"<<endl;
            sleep(5);
            exit(10);
        }
   }

   while(true) sleep(1);
   return 0;
}