我要评论什么是信号
信号是进程之间事件异步通知的一种方式，属于软中断。
- 信号的处理能力是进程的内置功能的一部分
- 进程即便没有收到信号也知道要如何处理信号
- 当进程收到一个信号时可能不会立刻处理，而是在合适时机处理（按优先级）
- 一个进程必须当信号产生，到信号开始被处理，就一定会有时间窗口，进程具有保存哪些信号已经发生了的能力。
前后台进程
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.函数sigfillset初始化set所指向的信号集,使其中所有信号的对应bit置位,表示 该信号集的有效信号包括系 统支持的所有信号。
3.注意,在使用sigset_ t类型的变量之前,一定要调 用sigemptyset或sigfillset做初始化,使信号集处于确定的状态。初始化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_flags字段包含一些选项,本章的代码都 把sa_flags设为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，所以仍旧会有僵尸进程
总结
以上为个人经验，希望能给大家一个参考，也希望大家多多支持代码网。
发表评论