Linux信号的产生、阻塞与捕捉

1.信号的基本概念

1）理解什么是信号？

1. ⽤户输⼊命令,在Shell下启动⼀个前台进程。

2. ⽤户按下Ctrl-C,这个键盘输⼊产⽣⼀个硬件中断。

3. 如果CPU当前正在执⾏这个进程的代码,则该进程的⽤户空间代码暂停执⾏,CPU从⽤户态 切换到内核态处理硬件中断。

4. 终端驱动程序将Ctrl-C解释成⼀个SIGINT信号,记在该进程的PCB中(也可以说发送了⼀ 个SIGINT信号给该进程)。（说明PCB可记录信号，是引用位图记录，位置信号的1/0表明信号的存在与否）（只有OS有资格修改目标进程的位图信息也只有OS能发送，发信号其实更准确来说是写信号）。

5. 当某个时刻要从内核返回到该进程的⽤户空间代码继续执⾏之前,⾸先处理PCB中记录的信号,发现有⼀个SIGINT信号待处理,⽽这个信号的默认处理动作是终⽌进程,所以直接终⽌进程⽽不再返回它的⽤户空间代码执⾏。
   注意：

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

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

8. 前台进程在运⾏过程中⽤户随时可能按下Ctrl-C⽽产⽣⼀个信号,也就是说该进程的⽤户空间代码执⾏到任何地⽅都有可能收到SIGINT信号⽽终⽌,所以信号相对于进程的控制流程来说是异步(Asynchronous)的。
   总结：

   1.进程要处理信号必须要认识信号（位图加规定）
   2.信号产生进程收到后有可能不立刻处理（先保存）而在合适的时候处理
   3.信号机制的产生对进程来说是异步的执行流并没有关系
   4.信号处理的三种方法：执行默认信号/忽略/自定义
   5.如果当前信号不能被处理就先记录。

2）信号列表

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

每个信号都有⼀个编号和⼀个宏定义名称,这些宏定义可以在signal.h中找到,例如其中有定义 #define SIGINT 2 。 1-31为普通信号，34-64为实时信号。这些信号各自在什么条件下产生，默认的处理动作是什么，在signal（7）中都有详细说明：man 7 signal

2.信号的产生

1）产生信号的方法概述

《1》终端产生
Ctrl+c产生SIGINT信号
Ctrl+\产生SIGQUIT信号
Ctrl+Z产生SIGTSTP信号
《2》硬件异常产生
,这些条件由硬件检测到并通知内核,然后内核向当前进程发送适当的信 号。例如当前进程执⾏了除以0的指令,CPU的运算单元会产⽣异常,内核将这个异常解释 为SIGFPE信号发送给进程。再⽐如当前进程访问了⾮法内存地址,MMU会产⽣异常,内核 将这个异常解释为SIGSEGV信号发送给进程。
《3》kill产生
⼀个进程调⽤kill(2)函数可以发送信号给另⼀个进程。 可以⽤kill(1)命令发送信号给某个进程,kill(1)命令也是调⽤kill(2)函数实现的,如果不明确指定信号则发送SIGTERM信号,该信号的默认处理动作是终⽌进程。 当内核检测到某种软件条件发⽣时也可以通过信号通知进程,例如闹钟超时产SIGALRM信号,向读端已关闭的管道写数据时产⽣SIGPIPE信号。 如果不想按默认动作处理信号,⽤户程序可以调⽤sigaction(2)函数告诉内核如何处理某种信号.
《4》软件条件产生

2）终端产生信号

SIGINT的默认处理动作是终⽌进程,SIGQUIT的默认处理动作是终⽌进程并且Core Dump,现在我们来验证⼀下。
Core Dump
⾸先解释什么是Core Dump。当⼀个进程要异常终⽌时,可以选择把进程的⽤户空间内存数据全部 保存到磁盘上,⽂件名通常是core,这叫做Core Dump。进程异常终⽌通常是因为有Bug,⽐如⾮法内存访问导致段错误,事后可以⽤调试器检查core⽂件以查清错误原因,这叫做Post-mortemDebug（事后调试）。
⼀个进程允许产⽣多⼤的core⽂件取决于进程的Resource Limit(这个信息保存 在PCB中)。默认是不允许产⽣core⽂件的,因为core⽂件中可能包含⽤户密码等敏感信息,不安全。在开发调试阶段可以⽤ulimit命令改变这个限制,允许产⽣core⽂件。

 $ ulimit -c 1024//修改core文件允许产生最大1024k
 $ ulimit -a //查看资源

事后调试：

• $ ulimit -c 1024
• 写一个死循环程序，使用ctrl + \将它终止掉，ls发现会多一个core.文件。
  
• 使用gdb调试，core-file core.文件。
• core文件直接帮我们定位出来错误的地方。

3）调用系统函数向进程发信号

《1》kill命令

kill命令是调⽤kill函数实现的。kill函数可以给⼀个指定的进程发送指定的信号。

#include<signal.h>
int kill(pid_t pid,int signo)；//kill命令的调用kill函数实现的
返回值：成功返回0，失败返回-1

⾸先在后台执⾏死循环程序

然后⽤kill命令给它发SIGSEGV信号

之所以要再次回⻋才显⽰ Segmentation fault ,是因为在13972进程终⽌
掉 之前已经回到了Shell提⽰符等待⽤户输⼊下⼀条命令,Shell不希望Segmentation fault信息和⽤户的输⼊交错在⼀起,所以等⽤户输⼊命令之后才显⽰。

kill -SIGSEGV  进程PID与`kill -11 进程PID（11是SIGSEGV的编号）` 相同。

以往遇到的段错误都是由⾮法内存访问产⽣的,⽽这个程序本⾝没错,给它发SIGSEGV也能产⽣段错误

《2》raise函数

给当前进程发送指定信号(自己给自己发)

#include<signal.h>
int raise(int signo);
返回值：成功返回0，失败返回-1

《3》abort函数

使当前进程接收到信号⽽异常终⽌

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

4）软件条件产生信号

SIGPIPE是⼀种由软件条件产⽣的信号,当读端将自己的文件描述符关闭，OS会向写端发送一个SIGPIPE信号来关闭写端。

《1》alarm函数

#include<unistd.h>
unsigned int alarm(unsigned int seconds);
功能：设置一个闹钟，告诉内核在seconds秒后给当前进程发送SIGALRM信号，该信号的默认动作是终止进程

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

eg:下面这个程序作用是2秒钟之内不停的数数，2秒钟到了就被SIGALRM信号终⽌.

#include<stdio.h>
#include<unistd.h>

int main()
{
  int count = 0;
  alarm(2);
  for(count = 0;2;count++){
    printf("count = %d\n",count);
  }
  return 0;
}

《2》signal函数

#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
//signum是信号编号，
//handler是一个函数指针，这个函数指针指向的是对默认处理替换的方法函数

3.阻塞信号

1）信号其他相关常见概念

• 实际执行信号的处理动作称为信号递达（Delivery）（要递达绝对没有阻塞）
• 信号从产生到递达之间的状态，称为信号未决（Pending）

pending->block->阻塞 pending->未block->合适时递达

• 进程可以选择阻塞（Block）某个信号。（阻塞也叫做屏蔽）没处理除非解除阻塞。
• 被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作。
• 阻塞与忽略是不同的，只要信号被阻塞就不会递达，而忽略是在递达之后，可选的一种处理动作。（忽略表明处理了）

2）在内核中的表达

信号在内核中的表示示意图：（位图存储）

由上图知

block的0/1表明是否被屏蔽。
pending0/1表明信号是否存在。信号产生时，内核在进程控制块中的未决标志直到信号递达才清除该标志。图中的2号信号还没有被处理。
handler表示处理动作：函数指针数组，先编号找到位置，再将函数指针放入。
如果在进程解除对某信号的阻塞之前这种信号产⽣过多次,将如何处理?POSIX.1允许系统递送该信号⼀次或多次。Linux是这样实现的:常规信号在递达之前产⽣多次只计⼀
次,⽽实时信号在递达之前产⽣多次可以依次放在⼀个队列⾥。

3）sigset_t

位图，包含block表和pending表。 每个信号只有⼀个bit的未决标志,⾮0即1,不记录该信号产⽣了多少次,阻塞标志也是这样表⽰的。 因此,未决和阻塞标志可以⽤相同的数据类型sigset_t来存储,sigset_t称为信号集,这个类型可以表⽰每个信号的“有效”或“⽆效”状态,在阻塞信号集中“有效”和“⽆效”的含义是该信号是否被阻塞,⽽在未决信

号集中“有效”和“⽆效”的含义是该信号是否处于未决状态。 阻塞信号集也叫做当前进程的信号屏蔽字(Signal Mask),这⾥的“屏蔽”应该理解为阻塞⽽不是忽略。

4）信号集操作函数

sigsett类型对于每种信号⽤⼀个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。

5）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：set包含了我们希望添加到当前信号屏蔽字的信号，相当于mask=mask|set
SIG_UNBLOCK：set包含了我们希望从当前信号屏蔽字中解除阻塞的信号相当于mask=mask&~set
SIG_SETMASK:设置当前信号屏蔽字为set所指向的值，相当于mask=set

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

6）sigpending函数

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

#include<signal.h>
int sigpending(sigset_t *set)；

下面我们使用下刚才学习的函数：

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


void printsigset(sigset_t *set)
{
  int i = 0;
  for(;i<32;i++)
  {
    if(sigismember(set,i))
    {
      putchar('1');
    }
    else{
      putchar('0');
    }
  }
  puts("");
}

int main()
{
   sigset_t s,p;//定义信号集对象，并清空初始化
   sigemptyset(&s);
   sigaddset(&s,SIGQUIT);
   sigprocmask(SIG_BLOCK,&s,NULL);//设置阻塞信号集，阻塞SIGQUIT信号
   while(1){
     sigpending(&p);//获取未决信号集
     printsigset(&p);
     sleep(1);
   }
}

运行该程序，每秒钟把各信号的未决状态打印一遍，由于我们阻塞了SIGQUIT信号，按Ctrl+\会使SIGQUIT处于未决状态，如下图所示。

使用Ctrl+C仍然可以终止程序，因为SIGINT信号没有阻塞。

4.捕捉信号

1)信号的捕捉

《1》首先我们先了解下内核态和用户态的基本概念

• 用户态：用户执行自身代码

• 内核态：执行内核代码的状态
  使用系统调用接口时可以由用户态变为内核态，返回时再又内核态转为用户态，系统调用接口的存在就是为了保护OS，普通用户不能访问OS的代码数据。

  切入内核的方式除了系统调用还有中断，异常，缺陷等方式

《2》内核如何实现信号的捕捉

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

 信号处理在内核态切换至用户态的时候，线程间的切换，进程间的切换也发生在内核态切换用户态的期间。

《3》sigaction函数

#include <signal.h>
int sigaction(int signo, const struct sigaction *act, struct sigaction *oact); 
//const sigaction *act是指处理新的信号
//struct sigaction *oact是将旧的返回（输出型参数）

struct sigaction 
{
 void(*) (int)     sa_handler  ;
 sigset_t          sa_mask  ;
  int               sa_flags   ;
void(*) (int,  siginfo_t *,     void *)         sa_sigaction   ;


}

sigaction函数可以读取和修改与指定信号相关联的处理动作。调⽤成功则返回0,出错则返回- 1。signo是指定信号的编号。若act指针⾮空,则根据act修改该信号的处理动作。若oact指针⾮ 空,则通过oact传出该信号原来的处理动作。act和oact指向sigaction结构体:将sahandler赋值为常数SIGIGN传给sigaction表⽰忽略信号,赋值为常数SIG_DFL表⽰执⾏系统默认动作,赋值为⼀个函数指针表⽰⽤⾃定义函数捕捉信号,或者说向内核注册了⼀个信号处理函 数,该函数返回值为void,可以带⼀个int参数,通过参数可以得知当前信号的编号,这样就可以⽤同⼀个函数处理多种信号。显然,这也是⼀个回调函数,不是被main函数调⽤,⽽是被系统所调用的。

当某个信号的处理函数被调⽤时,内核⾃动将当前信号加⼊进程的信号屏蔽字,当信号处理函数返回时⾃动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产⽣,那么 它会被阻塞到当前处理结束为⽌。 如果在调⽤信号处理函数时,除了当前信号被⾃动屏蔽之外,还希望⾃动屏蔽另外⼀些信号,则⽤samask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时⾃动恢复原来的信号屏蔽字。 saflags字段包含⼀些选项,saflags设为0 ,sasigaction是实时信号的处理函数。

《4》pause

#include <unistd.h>
int pause(void)；

pause函数使调⽤进程挂起直到有信号递达。如果信号的处理动作是终⽌进程,则进程终 ⽌,pause函数没有机会返回;如果信号的处理动作是忽略,则进程继续处于挂起状态,pause不返回;如果信号的处理动作是捕捉,则调⽤了信号处理函数之后pause返回-1,errno设置为EINTR, 所以pause只有错的返回值(只有出错返回值含有exec函数系列，进程函数替换)。错误码EINTR表 ⽰“被信号中断”。

pause要有返回值则:1：收到信号。2：自定义捕捉信号。

下面我们用alarm和pause实现mysleep函数
思路

• main 函数调用mysleep函数,然后调用sigaction注册SIGALRM信号的处理函数sig_alrm.
• 调用alarm（nsecs）设为闹钟
• 调用pause等待，内核切换到别的进程运行
• nsecs秒后，闹钟超时，内核发SIGAKRM给这个进程
• 从内核态返回这个进程的用户态之前处理未决信号，发现有SIGALRMB信号被自动屏蔽，从从sig_alrm函数返回时SIGALRM信号⾃动解除屏蔽。然后⾃动执⾏系统调⽤sigreturn再次进⼊ 内核,再返回⽤户态继续执⾏进程的主控制流程(main函数调⽤的mysleep函数)。
• pause函数返回-1,然后调⽤alarm(0)取消闹钟,调⽤sigaction恢复SIGALRM信号以前的处理动作。
  实现代码：

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

void  sig_alrm(int signo)
{

}

unsigned int mysleep(unsigned  int  nsecs)
{
  struct sigaction  new,old;
  unsigned  int unslept = 0;
  new.sa_handler = sig_alrm;
  sigemptyset(&new.sa_mask);
  new.sa_flags = 0;
  sigaction(SIGALRM,&new,&old);//注册信号处理函数
  alarm(nsecs);//设置闹钟
  pause();
  unslept = alarm(0);//清空闹钟
  sigaction(SIGALRM,&old,NULL);//恢复信号默认动作
  return unslept;
}



int main()
{
  while(1){
    mysleep(1);
    printf("1 seconds passed\n");
  }
  return 0;
}

2）可重入函数

《1》引入

我们以单链表的头插为例：

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

《2》重入

上例中的insert函数被不同的控制流程调用，有可能在第一次调用还没有返回时就再次进入该函数，这称为重入。

《3》不可重入函数

上例中insert函数访问一个全局链表，有可能因为重入而造成错乱，像这样的函数称为不可重入函数

不可重入函数的条件：

• 调用了malloc或free，因为malloc也是用全局链表来管理堆的
• 调用了标准I/O库函数。标准I/O库的很多实现都以不可重入的方式使用全局数据结构

《4》可重入函数

如果一个函数只访问自己的局部变量或参数则称为可重入函数。

《5》多线程或多CPU编程要使用volatile关键字

对于程序中存在多个执⾏流程访问同⼀全局变量的情况,volatile限定符是必要的,此外,虽然程 序只有单⼀的执⾏流程,但是变量属于以下情况之⼀的,也需要volatile限定:

1>变量的内存单元中的数据不需要写操作就可以⾃⼰发⽣变化,每次读上来的值都可能不⼀样。
2>即使多次向变量的内存单元中写数据,只写不读,也并不是在做⽆⽤功,⽽是有特殊意义的 。
什么样的内存单元会具有这样的特性呢?肯定不是普通的内存,⽽是映射到内存地址空
间的硬件寄存器,例如串⼝的接收寄存器属于上述第⼀种情况,⽽发送寄存器属于上述第⼆种情况。
3>.sig_ atomic_ t类型的变量应该总是加上volatile限定符,因为要使⽤sigatomict类型的理由也正 是要加volatile限定符的理由。

5.竞态条件与sigsuspend函数

其实我们之前写的mysleep函数还是有缺陷的，设想这样的时序问题：

1. 注册SIGALRM信号的处理函数。
2. 调⽤alarm(nsecs)设定闹钟。
3. 内核调度优先级更⾼的进程取代当前进程执⾏,并且优先级更⾼的进程有很多个,每个都要 执⾏很⻓时间
4. nsecs秒钟之后闹钟超时了,内核发送SIGALRM信号给这个进程,处于未决状态。
5. 优先级更⾼的进程执⾏完了,内核要调度回这个进程执⾏。SIGALRM信号递达,执⾏处理函 数sig_alrm之后再次进⼊内核。
6. 返回这个进程的主控制流程,alarm(nsecs)返回,调⽤pause()挂起等待。
7. 可是SIGALRM信号已经处理完了,还等待什么呢?

出现这个问题的根本原因是系统运⾏的时序(Timing)并不像我们写程序时所设想的那样。虽然alarm(nsecs)紧接着的下⼀⾏就是pause(),但是⽆法保证pause()⼀定会在调⽤alarm(nsecs)之 后的nsecs秒之内被调⽤。由
于异步事件在任何时候都有可能发⽣(这⾥的异步事件指出现更⾼优 先级的进程),如果我们写程序时考虑不周密,就可能由于时序问题⽽导致错误,这叫做竞态条件

解决方式：
1）

1. 屏蔽SIGALRM信号
2. alarm(nsecs)
3. 解除对SIGALRM信号的屏蔽
4. pause();

上述过程相对靠谱，但是第三步在解除信号屏蔽的时候，也可能立刻对递达。
2）

1. 屏蔽SIGALRM信号;
2. alarm(nsecs);
3. pause();
4. 解除对SIGALRM信号的屏蔽

这样更不⾏了,还没有解除屏蔽就调⽤pause,pause根本不可能等到SIGALRM信号。要是“解除信号屏蔽”和“挂起等待信号”这两步能合并成⼀个原⼦操作就好了,这正是sigsuspend函数的功 能。sigsuspend包含了pause的挂起等待功能,同时解决了竞态条件的问题,在对时序要求严格的场合下都应该调⽤sigsuspend⽽不是pause。

sigsuspend函数

#include <signal.h>
int sigsuspend(const sigset_t *sigmask);

和pause⼀样,sigsuspend没有成功返回值,只有执⾏了⼀个信号处理函数之后sigsuspend才返回,返回值为-1,errno设置为EINTR。 调⽤sigsuspend时,进程的信号屏蔽字由sigmask参数指定,可以通过指定sigmask来临时解除对某 个信号的屏蔽,然后挂起等待,当sigsuspend返回时,进程的信号屏蔽字恢复为原来的值,如果原来对该信号是屏蔽的从sigsuspend返回后仍然是屏蔽的。

接下来用sigsupend重新实现mysleep函数：

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

void  sig_alrm(int signo)
{

}

unsigned int mysleep(unsigned  int  nsecs)
{
  struct sigaction  new,old;
  sigset_t   newmask,oldmask,suspmask;
  unsigned  int unslept = 0;



  new.sa_handler = sig_alrm;
  sigemptyset(&new.sa_mask);
  new.sa_flags = 0;
  sigaction(SIGALRM,&new,&old);//注册信号处理函数


  sigemptyset(&newmask);
  sigaddset(&newmask,SIGALRM);
  sigprocmask(SIG_BLOCK,&newmask,&oldmask);



  alarm(nsecs);//设置闹钟

  suspmask = oldmask ;
  sigdelset(&suspmask,SIGALRM);
  sigsuspend(&suspmask);



  

  unslept = alarm(0);//清空闹钟
  sigaction(SIGALRM,&old,NULL);//恢复信号默认动作
  sigprocmask(SIG_SETMASK,&oldmask,NULL);
  return unslept;
}



int main()
{
  while(1){
    mysleep(1);
    printf("1 seconds passed\n");
  }
  return 0;
}

如果在调⽤mysleep函数时SIGALRM信号没有屏蔽：

调⽤sigprocmask(SIG_ BLOCK, &newmask, &oldmask),屏蔽SIGALRM。
调⽤sigsuspend(&suspmask);解除对SIGALRM的屏蔽,然后挂起等待待。
SIGALRM递达后suspend返回,⾃动恢复原来的屏蔽字,也就是再次屏蔽SIGALRM。
调⽤sigprocmask(SIG_ SETMASK, &oldmask, NULL);再次解除对SIGALRM的屏蔽。

6.SIGCHLD信号

⽤wait和waitpid函数清理僵⼫进程,⽗进程可以阻塞等待⼦进程结束,也可以⾮阻 塞地查询是否有⼦进程结束等待清理(也就是轮询的⽅式)。采⽤第⼀种⽅式,⽗进程阻塞了就不 能处理⾃⼰的⼯作了;采⽤第⼆种⽅式,⽗进程在处理⾃⼰的⼯作的同时还要记得时不时地轮询⼀ 下,程序实现复杂。
其实,⼦进程在终⽌时会给⽗进程发SIGCHLD信号,该信号的默认处理动作是忽略,⽗进程可以⾃ 定义SIGCHLD信号的处理函数,这样⽗进程只需专⼼处理⾃⼰的⼯作,不必关⼼⼦进程了,⼦进程 终⽌时会通知⽗进程,⽗进程在信号处理函数中调⽤wait清理⼦进程即可。

请编写⼀个程序完成以下功能:⽗进程fork出⼦进程,⼦进程调⽤exit(2)终⽌,⽗进程⾃定 义SIGCHLD信号的处理函数,在其中调⽤wait获得⼦进程的退出状态并打印。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
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);
 pid_t cid;
 if((cid = fork()) == 0){//child
 printf("child : %d\n", getpid());
 sleep(3);
 exit(1);
 }
 while(1){
 printf("father proc is doing some thing!\n");
 sleep(1);
 }
 return 0;
}