文章目录
- 信号的概念
- 谈谈硬件
- 信号的产生
- 1. 键盘组合键
- 2. kill命令
- 3. 系统调用
- 异常
- 4. 由硬件异常产生信号
- 5. 由软件异常产生信号
- Core Dump
- 信号的保存
- sigset_t
- 信号集操作函数
- sigprocmask
- sigpending
- 信号的处理
- 重谈地址空间
- 捕捉信号
- 1. 内核如何实现信号的捕捉
- 2. sigaction
- 问题一：pending位图，什么时候从1->0？
- 问题2： 信号被处理的时候，对应的信号也会被添加到block表中吗？
- 可重入函数
- volatile
- SIGCHLD信号
信号的概念
我们生活中的下课铃声，红绿灯，快递发短信取件码等。。。都是信号
如何认识信号：
- 识别信号（知道信号的处理方法）
- 即使是我们现在没有产生信号，我也知道信号产生之后干什么？
- 信号产生了，我们可能不立即处理这个信号，在合适的时候处理，因为我们可能正在做更重要的事情，所以信号产生后，有一个时间窗口，在信号处理时，在这个时间窗口就必须记住信号的到来
上面所说的信号：
- 进程必须识别 + 能够处理信号，如果信号没有产生，也要具备处理信号的能力（处理信号的能力，属于进程内置功能的一部分）。
- 进程即便是没有收到信号，也能知道哪些信号该怎么处理。
- 当进程真的收到一个具体的信号的时候，进程可能并不会立即处理这个信号，在合适的时候进行处理（这里的在合适的时候有三种方式：1. 默认动作。2. 忽略。3. 自定义动作（比如信号的捕捉））。
- 一个进程必须当信号产生，到信号开始处理，就一定有时间窗口，进程具有临时保存哪些信号已经发生了的能力。
- 当一个进程运行起来的时候，我们按下键盘上的
ctrl + c，本质是被进程解释成为了收到了信号（ 2号信号 ）
我们可以输入kill -l来查看所有的信号
-
1 ~ 31是普通信号（后面要学一些）
-
34 ~ 64 是实时信号（我们不关注）
-
每个信号都有一个编号和一个宏定义名称,这些宏定义可以在signal.h中找到
-
编号34以上的是实时信号,本章只讨论编号34以下的信号,不讨论实时信号。这些信号各自在什么条件下产生,默认的处理动作是什么,在signal(7)中都有详细说明:
man 7 signal
-
Linux中，一次登录中，一个终端，一般配上一个
bash，每一个登录，只允许一个进程是前台进程，但是可以允许多个进程是后台进程 -
也就是是说刚刚的程序是比bash更前，bash变成后台进程了，在按下
ctrl + c后，进程收到了2号信号后就退出了，但是我们平时使用的bash按下ctrl + c后为什么bash不会退出呢？这是因为bash对ctrl + c做了特殊处理 -
我们也可以将进程运行到后台，后面加一个
&
./myprocess &
- 我们可以自定义收到指定信号的动作：
sighandler_t signal(int signum, sighandler_t handler);
- 第一个参数是要收到的信号
- 第二个参数是收到这个参数后该执行的方法
- 信号的产生，和我们自己的代码运行是异步的，属于软中断。
- 信号的本质是仿照硬件的中断的行为。
#include <iostream>
#include <signal.h>
#include <unistd.h>
void myhandler(int sig)
{
std::cout << "process get a signal " << sig << std::endl;
}
int main()
{
// 只要设置了一次，后面都有效
signal(SIGINT, myhandler);
// 信号的产生，和我们自己的代码运行是异步的
while (true)
{
std::cout << "I am a crazy process" << std::endl;
sleep(1);
}
return 0;
}
- 按下
ctrl + c后，收到了2号信号后，执行该方法
谈谈硬件
- 键盘数据是如何输入给内核的，
ctrl + c又是如何变成信号的？- 键盘被按下，肯定是OS先知道
- OS怎么知道键盘上有数据了？
键盘是由中断来工作的
信号的产生
1. 键盘组合键
- 不是所有的信号会被捕捉的
#include <iostream>
#include <signal.h>
#include <unistd.h>
void myhandler(int sig)
{
std::cout << "process get a signal " << sig << std::endl;
}
int main()
{
// 只要设置了一次，后面都有效
signal(SIGINT, myhandler); // 2号信号 -> ctrl + '\'
// 信号的产生，和我们自己的代码运行是异步的
signal(SIGQUIT, myhandler); // 3号信号 -> ctrl + '\'
signal(SIGSTOP, myhandler); // 19号信号 -> ctrl + 'z' 不会被捕捉
// 看看哪个信号可以被捕捉
for (int i = 0; i < 31; i++)
{
signal(i, myhandler);
}
while (true)
{
std::cout << "I am a crazy process : " << getpid() << std::endl;
sleep(1);
}
return 0;
}
- 经过测试：
- 只有9（杀进程）和19（暂停）号信号不能被捕捉，其他全部都可以
2. kill命令
kill -signal pid
3. 系统调用
int kill(pid_t pid, int sig);
- 给pid，发送指定信号
void Usage(std::string proc)
{
std::cout << "Usage:\n\t" << proc << "signum pid\n"
<< std::endl;
}
// mykill signal pid
int main(int argc, char*argv[])
{
if(argc != 3)
{
Usage(argv[0]);
exit(-1);
}
int signum = atoi(argv[1]);
pid_t pid = atoi(argv[2]);
int n = kill(pid,signum);
if(n < 0)
{
perror("kill");
exit(-2);
}
return 0;
}
int raise(int sig);
- 这个函数给自己发送信号
- 引起一个正常的进程直接终止
void abort(void);
abort(); // 6号信号,自己会退出 = kill(getpid(), 6); // 但是在外面发kill -6 pid 就不会退出
#include <iostream>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>
void Usage(std::string proc)
{
std::cout << "Usage:\n\t" << proc << "signum pid\n"
<< std::endl;
}
void myhandler(int sig)
{
std::cout << "process get a signal " << sig << std::endl;
}
int main()
{
// signal(2, myhandler);
signal(SIGABRT, myhandler);
int cnt = 0;
while (true)
{
std::cout << "I am a process, pid: " << getpid() << std::endl;
sleep(1);
cnt++;
if (cnt % 2 == 0)
{
// kill(getpid(), 2);
// raise(2); // 给自己发信号
// abort(); // 6号信号,自己会退出 = kill(getpid(), 6); // 但是在外面发kill -6 pid 就不会退出
}
}
return 0;
}
- 信号的产生方式，但是无论信号如何产生，最终一定是谁发送给进程的？OS，因为OS是进程的管理者
异常
4. 由硬件异常产生信号
// 信号为什么会一直被触发？？
void handler(int signo)
{
cout << "...get a sig, number: " << signo <<endl; //我什么都没干，我只是打印了消息
}
int main()
{
signal(SIGSEGV, handler); // 19号信号
cout << "point error before" << endl;
int *p = nullptr;
*p = 100; // 野指针
// int a = 10;
// a /= 0; // 异常
cout << "point error before" << endl;
sleep(1);
return 0;
}
- 在使用man手册查看这里提示这个错误是段错误
man 7 signal
- 硬件异常被硬件以某种方式被硬件检测到并通知内核,然后内核向当前进程发送适当的信号。例如当前进程执行了除以0的指令,CPU的运算单元会产生异常,内核将这个异常解释 为SIGFPE信号发送给进程。再比如当前进程访问了非法内存地址,MMU会产生异常,内核将这个异常解释为SIGSEGV信号发送给进程。
5. 由软件异常产生信号
SIGPIPE是一种由软件条件产生的信号,在“管道”中已经介绍过了。本节主要介绍alarm函数 和SIGALRM信号。
unsigned int alarm(unsigned int seconds);
- 这个函数的返回值是0或者是以前设定的闹钟时间还余下的秒数。打个比方,某人要小睡一觉,设定闹钟为30分钟之后响,20分钟后被人吵醒了,还想多睡一会儿,于是重新设定闹钟为15分钟之后响,“以前设定的闹钟时间还余下的时间”就是10分钟。如果seconds值为0,表示取消以前设定的闹钟,函数的返回值仍然是以前设定的闹钟时间还余下的秒数
- 代码测试：
void handler(int signo)
{
sleep(1);
cout << "...get a sig, number: " << signo << endl;
}
int main()
{
signal(SIGALRM, handler); // 14号信号
int n = alarm(5); // 设置闹钟，5秒之后会响
while (1)
{
cout << "proc is running..., pid: " << getpid() << endl;
sleep(1);
}
}
- 这里的闹钟为什么只响了一次？因为只设置了一次，而且这个闹钟不是异常
void work()
{
cout << "print log..." << endl;
}
void handler(int signo)
{
work();
sleep(1);
cout << "...get a sig, number: " << signo << endl;
int n = alarm(5);
cout << "剩余时间：" << n << endl;
}
int main()
{
signal(SIGALRM, handler); // 14号信号
int n = alarm(50); // 设置闹钟，50秒之后会响
while (1)
{
cout << "proc is running..., pid: " << getpid() << endl;
sleep(1);
}
}
- 现在我们有5大特征可以产生信号
using namespace std;
int main()
{
pid_t id = fork();
if (id == 0)
{
// child
int cnt = 500;
while (cnt)
{
cout << "I am child process, pid " << getpid() << "cnt:" << cnt << endl;
sleep(1);
cnt--;
}
}
// 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;
}
return 0;
}
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 -
发送2号信号
- 发送8号信号
- 如果查看不到的话我们需要打开
查看：
ulimit -a
设置：
ulimit -c 1024
- 打开系统的core dump功能，一旦进程出现异常，OS会将进程出异常，OS会将进程在内存中的运行信息，给我dump（转储）到进程的当前目录（磁盘），形成core.pid文件：核心转储（core dump），这是一种运行时错误，直接复现问题之后，直接定位到出错行，先运行，在core-file：事后调试。
对于普通信号而言，对于进程而言，自己有还是没有收到哪一个信号，是给进程的PCB发的
task_struct里有一个int signal：是位图管理
- 比特位的内容是0还是1，表明是否收到
- 比特位的位置（第几个），表示信号的编号
- 所谓的发信号，本质就是OS去修改
task_struct的信号位图对应的比特位，也就是写信号
- 意味着OS是进程的管理者，只有它有资格才能修改
task_struct内部的属性！！！
信号的保存
- 实际执行信号的处理动作称为信号递达(Delivery)
- 信号从产生到递达之间的状态,称为信号未决(Pending)。
- 进程可以选择阻塞 (Block )某个信号。
- 被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作.
- 注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作。
-
进程收到信号后，可能不会立即处理这个信号，信号不会被处理，就要有一个时间窗口
-
信号的范围1,31，每一种信号都要有自己的一种处理方法【handler表】，这个表是一个函数指针类型，是一个函数指针数组
- pending：记录是否收到了信号以及哪些信号
- block：记录特定型号是否被屏蔽
- handler：记录的是每种信号所对应的处理关系和处理方法
两张位图+一张函数指针数组表对信号的管理
- 每个信号都有两个标志位分别表示阻塞(block)和未决(pending),还有一个函数指针表示处理动作。信号产生时,内核在进程控制块中设置该信号的未决标志,直到信号递达才清除该标志。在上图的例子中,SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作。
- SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞。
- SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler。
- 如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?POSIX.1允许系统递送该信号一次或多次。Linux是这样实现的：常规信号在递达之前产生多次只计一次,而实时信号在递达之前产生多次可以依次放在一个队列里。
#include <iostream>
#include <signal.h>
#include <unistd.h>
int main()
{
signal(2, SIG_IGN);// 对2号信号屏蔽
while(true)
{
std::cout << "hello" << std::endl;
sleep(1);
}
return 0;
}
- 忽略：
int main()
{
signal(2, SIG_ERR); // 对2号信号默认
while(true)
{
std::cout << "hello" << std::endl;
sleep(1);
}
return 0;
}
- 终止：
sigset_t
- 每个信号只有一个bit的未决标志,非0即1,不记录该信号产生了多少次,阻塞标志也是这样表示的。
- 因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储,sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态,在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞,而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。下一节将详细介绍信号集的各种操作。 阻塞信号集也叫做当前进程的信号屏蔽字(Signal Mask),这里的“屏蔽”应该理解为阻塞而不是忽略。
信号集操作函数
- 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); // 判断一个信号是否在
- 函数sigemptyset初始化set所指向的信号集,使其中所有信号的对应bit清零,表示该信号集不包含 任何有效信号。
- 函数sigfillset初始化set所指向的信号集,使其中所有信号的对应bit置位,表示 该信号集的有效信号包括系统支持的所有信号。
- 注意,在使用sigset_ t类型的变量之前,一定要调 用sigemptyset或sigfillset做初始化,使信号集处于确定的状态。初始化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
-
读取当前进程的未决信号集,通过set参数传出。调用成功则返回0,出错则返回-1。 下面用刚学的几个函数做个实验。程序如下:
-
在发送2号信号后，比特位变成了1
- 在解除屏蔽后：比特位变成了0
- 一定有一些是不会被屏蔽
void PrintPending(sigset_t &pending)
{
for (int signo = 31; signo >= 1; signo--)
{
if (sigismember(&pending, signo))
{
cout << "1";
}
else
{
cout << "0";
}
}
cout << " I am pid: " << getpid();
cout << endl
<< endl;
}
int main()
{
// 尝试将所有信号进行屏蔽
sigset_t bset, oset;
sigemptyset(&bset);
sigemptyset(&oset);
for (size_t i = 1; i < 31; i++)
{
sigaddset(&bset, i);
}
sigprocmask(SIG_SETMASK, &bset, &oset);
// 打印
sigset_t pending;
while (true)
{
int n = sigpending(&pending);
if (n < 0)
continue;
PrintPending(pending);
sleep(1);
}
return 0;
}
- 经过测试，
9和19号信号不可被屏蔽，和当时测试的捕捉的测试一样
信号的处理
什么时候被处理？
-
当进程从内核态返回到用户态的时候，进行信号的检测和处理！
-
调用系统调用，操作系统是会自动会做“身份”切换的，用户的身份变成内核身份，或者反着来
int 80 —> 从用户态陷入内核态
重谈地址空间
-
用户级页表有几份？
- 有几个进程就有几份用户级页表，因为进程具有独立性
-
内核级页表有几份？
- 每个进程看到的3 ~ 4 GB的东西都是一样的，在整个系统里，进程再怎么切换，3 ~4 GB的内容是不变的
- 站在进程视角：我们调用系统中的方法，就是在我自己的地址空间中进行执行的
- 站在操作系统角度：任何一个时刻都会有进程在执行，我们想执行操作系统的代码，就可以随时执行
-
操作系统的本质是一个基于时钟中断的一个死循环
-
在计算机硬件中，有一个时钟芯片，每隔很短的时间，向计算机发送时钟中断
- 内核态：允许访问操作系统的代码和数据
- 用户态：只能访问用户自己的代码和数据
进程是会被调度的！！！
捕捉信号
1. 内核如何实现信号的捕捉
如果信号的处理动作是用户自定义函数,在信号递达时就调用这个函数,这称为捕捉信号。由于信号处理函数的代码是在用户空间的,处理过程比较复杂,举例如下: 用户程序注册了SIGQUIT信号的处理函数sighandler。 当前正在执行main函数,这时发生中断或异常切换到内核态。 在中断处理完毕后要返回用户态的main函数之前检查到有信号SIGQUIT递达。 内核决定返回用户态后不是恢复main函数的上下文继续执行,而是执行sighandler函 数,sighandler和main函数使用不同的堆栈空间,它们之间不存在调用和被调用的关系,是 两个独立的控制流程。 sighandler函数返回后自动执行特殊的系统调用sigreturn再次进入内核态。 如果没有新的信号要递达,这次再返回用户态就是恢复main函数的上下文继续执行了。
2. sigaction
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
-
sigaction函数可以读取和修改与指定信号相关联的处理动作。调用成功则返回0,出错则返回 -1。
-
signo是指定信号的编号。若act指针非空,则根据act修改该信号的处理动作。若oact指针非 空,则通过oact传出该信号原来的处理动作。act和oact指向sigaction结构体:
-
将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号,赋值为常数SIG_DFL表示执行系统默认动作,赋值为一个函数指针表示用自定义函数捕捉信号,或者说向内核注册了一个信号处理函 数,该函数返回值为void,可以带一个int参数,通过参数可以得知当前信号的编号,这样就可以用同一个函数处理多种信号。显然,这也是一个回调函数,不是被main函数调用,而是被系统所调用。
- 我们只需要关心这两个：
struct sigaction {
void (*sa_handler)(int); // 处理方法
sigset_t sa_mask;
};
问题一：pending位图，什么时候从1->0？
#include <iostream>
#include <cstring>
#include <signal.h>
#include <unistd.h>
void PrintPending()
{
sigset_t set;
sigpending(&set);
for (int signo = 31; signo >= 1; signo--)
{
if (sigismember(&set, signo))
std::cout << "1";
else
std::cout << "0";
}
std::cout << std::endl;
}
void handler(int signo)
{
PrintPending();
std::cout << "catch a signal, signal number" << signal << std::endl;
}
int main()
{
struct sigaction act, oact;
memset(&act, 0, sizeof(act));
memset(&oact, 0, sizeof(act));
act.sa_handler = handler;
sigaction(2, &act, &oact);
while (true)
{
std::cout << "I am a process " << getpid() << std::endl;
sleep(1);
}
return 0;
}
- 由此看出执行信号捕捉方法之前，先清0，在调用
问题2： 信号被处理的时候，对应的信号也会被添加到block表中吗？
void PrintPending()
{
sigset_t set;
sigpending(&set);
for (int signo = 31; signo >= 1; signo--)
{
if (sigismember(&set, signo))
std::cout << "1";
else
std::cout << "0";
}
std::cout << std::endl;
}
void handler(int signo)
{
std::cout << "catch a signal, signal number" << signal << std::endl;
while (true)
{
PrintPending();
sleep(1);
}
}
int main()
{
struct sigaction act, oact;
memset(&act, 0, sizeof(act));
memset(&oact, 0, sizeof(act));
act.sa_handler = handler;
sigaction(2, &act, &oact); // 捕捉2号
while (true)
{
std::cout << "I am a process " << getpid() << std::endl;
sleep(1);
}
return 0;
}
- 我们再来看看
sa_mask字段
这个字段很简单，也就是在处理一个信号的时候，同时也要屏蔽多个信号就可以使用这个字段添加进去
int main()
{
struct sigaction act, oact;
memset(&act, 0, sizeof(act));
memset(&oact, 0, sizeof(act));
sigemptyset(&act.sa_mask);
// 将1 3 4 信号也同时屏蔽
sigaddset(&act.sa_mask, 1);
sigaddset(&act.sa_mask, 3);
sigaddset(&act.sa_mask, 4);
act.sa_handler = handler;
sigaction(2, &act, &oact); // 捕捉2号
while (true)
{
std::cout << "I am a process " << getpid() << std::endl;
sleep(1);
}
return 0;
}
当某个信号的处理函数被调用时,内核自动将当前信号加入进程的信号屏蔽字,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么 它会被阻塞到当前处理结束为止。 如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字。 sa_flags字段包含一些选项,本章的代码都把sa_flags设为0,sa_sigaction是实时信号的处理函数,本章不详细解释这两个字段,有兴趣的同学可以在了解一下。
可重入函数
-
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
- 标准情况下，键入CTRL-C ,2号信号被捕捉，执行自定义动作，修改flag＝1 ， while 条件不满足,退出循环，进程退出
int flag = 0;
void handler(int signo)
{
std::cout << "catch a signal: " << signo << std::endl;
flag = 1;
}
int main()
{
signal(2, handler);
while (!flag)
; // 真
std::cout << "process quit normal" << std::endl;
return 0;
}
- 优化级别位O1，可以在
man g++里面查看优化级别
优化情况下，键入CTRL-C ,2号信号被捕捉，执行自定义动作，修改flag＝1 ，但是while 条件依旧满足,进程继续运行！但是很明显flag肯定已经被修改了，但是为何循环依旧执行？很明显， while 循环检查的flag，并不是内存中最新的flag，这就存在了数据二异性的问题。while 检测的flag其实已经因为优化，被放在了CPU寄存器当中。如何解决呢？很明显需要volatile
volatile int flag = 0;
void handler(int signo)
{
std::cout << "catch a signal: " << signo << std::endl;
flag = 1;
}
int main()
{
signal(2, handler);
while (!flag)
; // 真
std::cout << "process quit normal" << std::endl;
return 0;
}
volatile作用：保持内存的可见性，告知编译器，被该关键字修饰的变量，不允许被优化，对该变量的任何操作，都必须在真实的内存中进行操作
SIGCHLD信号
- 进程一章讲过用wait和waitpid函数清理僵尸进程,父进程可以阻塞等待子进程结束,也可以非阻塞地查询是否有子进程结束等待清理(也就是轮询的方式)。采用第一种方式,父进程阻塞了就不能处理自己的工作了;采用第二种方式,父进程在处理自己的工作的同时还要记得时不时地轮询一 下,程序实现复杂。
其实,子进程在终止时会给父进程发SIGCHLD信号,该信号的默认处理动作是忽略,父进程可以自定义SIGCHLD信号的处理函数,这样父进程只需专心处理自己的工作,不必关心子进程了,子进程终止时会通知父进程,父进程在信号处理函数中调用wait清理子进程即可。
- 请编写一个程序完成以下功能：父进程fork出子进程,子进程调用exit(2)终止,父进程自定义
SIGCHLD信号的处理函数,在其中调用wait获得子进程的退出状态并打印。
代码实现：
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;
}
}
int main()
{
signal(17, handler);
for (int i = 0; i < 10; i++)
{
pid_t id = fork();
if (id == 0)
{
while (true)
{
cout << "I am child process: " << getpid() << ", ppid: " << getppid() << endl;
sleep(5);
break;
}
cout << "child quit!!!" << endl;
exit(2);
}
sleep(1);
}
// father
while (true)
{
cout << "I am father process: " << getpid() << endl;
sleep(1);
}
return 0;
}
检测：
while :; do ps -axj | head -1 ; ps -axj | grep mysignal | grep -v grep; sleep 1; done
- 事实上,由于UNIX 的历史原因,要想不产生僵尸进程还有另外一种办法:父进程调 用sigaction将SIGCHLD的处理动作置为SIG_IGN,这样fork出来的子进程在终止时会自动清理掉,不 会产生僵尸进程,也不会通知父进程。系统默认的忽略动作和用户用sigaction函数自定义的忽略 通常是没有区别的,但这是一个特例。此方法对于Linux可用,但不保证在其它UNIX系统上都可 用。请编写程序验证这样做不会产生僵尸进程。
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;
}
}
int main()
{
signal(17, SIG_IGN); // SIG_DFL -> action -> IGN
for (int i = 0; i < 10; i++)
{
pid_t id = fork();
if (id == 0)
{
while (true)
{
cout << "I am child process: " << getpid() << ", ppid: " << getppid() << endl;
sleep(5);
break;
}
cout << "child quit!!!" << endl;
exit(2);
}
//sleep(rand()%5+3);
sleep(1);
}
// father
while (true)
{
cout << "I am father process: " << getpid() << endl;
sleep(1);
}
return 0;
}
end…
