理解进程信号

---

1、生活中的信号

生活中的信号非常多，比如闹钟、红绿灯、烽火台的烽火、你妈妈的脸色、信号枪、鸡叫声…
当我们在特定的场景，接受到这些信号的时候，我们会立马想到或者做到什么呢？
比如：
在过马路时，我们看到红绿灯从红变为绿的时候，是不是就该过马路
在家中，突然看见你妈的脸色变得生气了，是不是我们就该躲着远远的
在运动会上，进行跑步比赛时，听到信号枪响了，是不是我们就该起跑了

再举个栗子：

• 你在网上买了很多件商品，再等待不同商品快递的到来。但即便快递没有到来，你也知道快递来临时，你该怎么处理快递。也就是你能“识别快递”
• 当快递员到了你楼下，你也收到快递到来的通知，但是你正在打游戏，需5min之后才能去取快递。那么在在这5min之内，你并没有下去去取快递，但是你是知道有快递到来了。也就是取快递的行为并不是一定要立即执行，可以理解成“在合适的时候去取”
• 在收到通知，再到你拿到快递期间，是有一个时间窗口的，在这段时间，你并没有拿到快递，但是你知道有一个快递已经来了。本质上是你“记住了有一个快递要去取”
• 当你时间合适，顺利拿到快递之后，就要开始处理快递了。而处理快递一般方式有三种：1. 执行默认动作（幸福的打开快递，使用商品）2. 执行自定义动作（快递是零食，你要送给你你的女朋友）3. 忽略快递（快递拿上来之后，扔掉床头，继续开一把游戏）
• 快递到来的整个过程，对你来讲是异步的，你不能准确断定快递员什么时候给你打电话
  所以无论是生或中的信号还是进程中的信号，当收到信号时。并不是立即处理的，而是在合适的时候处理，原因是在信号来临的时候，我们可能正在做更重要的事情。既然信号不能被立即处理，已经到来的信号，也应该被保存起来，等到合适的时候再处理

2、Linux中进程信号的概念

概念：信号是进程之间事件异步通知的一种方式，属于软中断
作用：操作系统通过信号告诉进程发生了某个事件，打断进程当前的操作，去处理这个事件
结合前面快递员的例子，进程就是你，操作系统就是快递员，信号就是快递

在Linux中，我们可以通过用kill -l命令可以察看系统定义的信号列表

通过这张图，可以发现没有32和33号信号，所以信号一共有62种
1~31号信号是从unix借鉴而来的，每个信号都有具体对应的系统事件，但是它们是非可靠信号，也就是有可能会使信号丢失----事件丢失
34~64号信号是后期扩充的，它们都没有具体对应的事件，起的名字也比较粗糙，但是它们是可靠信号，也就是不会使信号丢失，肯定能传达到进程
这些信号各自在什么条件下产生,默认的处理动作是什么,在signal(7)中都有详细说明，不知道的话，我们可以通过命令man 7 signal进行查看

3、信号的处理方式

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

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

4、信号的产生

信号的产生主要有四种方式：

1. 通过终端按键产生信号。
2. 调用系统函数向进程发送信号。
3. 由软件条件产生信号。
4. 硬件异常产生信号。

4.1 通过终端按键产生信号

有这样一个死循环的程序：

#include<stdio.h>
#include<unistd.h>
int main()
{
    while(1)
    {
        printf("hello fl\n");
        sleep(1);
    }
    return 0;
}

对于这样一个陷入死循环的程序，我们可以通过按键的方式(ctrl+c)来进行终止
Ctrl +c 是通过硬件终端的输入方式中断进程，它的本质也是通过系统向进程发送信号。在证明Ctrl c本质之前需要知道Ctrl c的本质是往前台进程发送信号，在一次会话中只允许打开一个前台进程

在Linux中的信号中，ctrl c 究竟是哪一个信号呢？答案是2号信号，在验证之前我们还需要了解一下signal()捕捉信号函数

signal的接口是捕获信号，对信号进行重定义，捕捉到了信号才会触发这个函数
第一个参数：signum是信号编号
第二个参数：handler是一个函数指针，该函数指针指向的函数是自己实现的，表明捕捉到该信号时，需要做什么事
重点：所用信号中，只有9号信号不能被捕捉
对上面的代码进行修改：

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

//通过signal注册对2号信号的处理动作，改成我们的自定义动作
void handler(int signal)
{
    printf("It generates signal %d\n", signal);
}

int main()
{
	//注册handler函数时，不是调用这个函数，只是当信号到来的时候
	//这个函数才会被调用
    signal(2, handler);
    while(1)
    {
        printf("hello fl\n");
        sleep(1);
    }
    return 0;
}

运行代码：

通过验证发现，ctrl c 确实是2号信号，实际SIGINT。但是只能终止前台进程，不能终止后台进程，我们也可以证明一下：

通过证明发现：ctrl c 并没有终止该进程，如果要终止这个后台进程，必须要使用kill -9 pid才能终止

总结：

• 可执行程序后面加一个&符，表示后台运行这样shell不必等待进程结束就可以接收新的命令，启动新进程当进程被设置为后台进程时，我们在命令行输入的消息流会和后台进程的信息混合在一起，这是因为bash进程是在前台的，我们可以输入信息，但是显示器只有一个，两个进程同时使用，说明他是临界资源，而这个临界资源又没有被保护，因此它的数据会发生混乱
• Shell可以同时运行一个前台进程和多个后台进程，只有前台进程才能接收到键盘输入的组合键信号
• 前台进程可以随时接收一个组合键信号，证明了进程相对于信号是异步的

通过上述可知，ctrl+c是2号信号SIGINT，默认处理动作是终止进程，而3号信号SIGQUIT的默认处理动作是终止进程并且Core Dump

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

在开发调试阶段可以用ulimit命令改变这个限制,允许产生core文件。 首先用ulimit命令改变Shell进程的Resource Limit,允许core文件最大为1024K: $ ulimit -c 1024

先看这样一段代码：

int main()
{
    while(1)
    {
        int* p = NULL;
        p = (int*)100;
        *p = 100;
        sleep(1);
    }
    return 0;
}

因为对空指针解引用，所以一定会报错。运行代码后出现了段错误：

当我们设置了core文件后，再运行代码：

生成的core文件是二进制文件，core文件是给个编译器看的，生成的core文件是为了事后调试(逐步逐过程为事前调试)，类似在VS中编写代码时报错，并清晰指出代码的具体信息（什么错误，哪里出错）

在Linux下，使用gdb调试器调试代码时，只需要加上core文件，就能定位出段错误出现的位置

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

调用kill函数

第一个参数：pid表示进程的进程号(pid)，表明给哪个进程发送信号
第二个参数：sig表示发送几号信号
返回值：0表示成功，-1表示失败

调用raise函数
rasie可以给当前进程发送指定的信号(自己给自己发送信号)

参数：sig表示要给自己发送几号信号
返回值：0表示成功，非0表示失败
代码演示：

int main()
{
    int i = 0;
    while(i < 10)
    {
        i++;
        printf("hello fl\n");
        sleep(5);
        raise(9);//给自己发送9号信号
    }
}

该进程5秒之后会给自己发送9号信号，最终会终止自己。运行代码：

调用abort函数

abort使当前进程收到信号而异常终止,给自己发送6号信号
因为调用abort函数总是能成功，所以不需要返回值
发送的是否是6号信号，我们可以验证一下：

void handler(int signal)
{
    printf("get a signal:%d\n", signal);
}

int main()
{
    signal(6, handler);
    while(1)
    {
        printf("hello fl\n");
        sleep(5);
        abort();
    }
}

运行代码：

我们发现6号信号被捕捉了，并且终止了该进程
小总结：

1.raise()可以给自己发送任意信号
2.abort()默认给自己发送的是6号信号，6号信号可以被捕捉，但是还是会被终止，而9号信号直接不可以被捕捉
3.OS作为进程的管理者，如果所有的信号都能被捕捉，那么OS将无法管理进程，那么这个缺陷很可能被一些病毒利用，因此9号信号不能被捕捉，OS拥有对进程的终止能力

4.3 由软件条件产生信号

Linux中有这样一个函数->alarm()，延迟的给进程发送信号。这个函数相当于一个闹钟，,也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号(14号信号), 该信号的默认处理动作是终止当前进程

参数：seconds是一个时间，类似于闹钟设定的时间
返回值：为0或者剩下的时间
举个栗子：
某人要睡个午觉，设定闹钟为30分钟之后响,20分钟后被人吵醒了,还想多睡一会儿,于是重新设定闹钟为15分钟之后响,“以前设定的闹钟时间还余下的时间”就 是10分钟。如果seconds值为0,表示取消以前设定的闹钟,函数的返回值仍然是以前设定的闹钟时间还余下的秒数

void handler(int signal)
{
    printf("get a signal:%d\n", signal);
    eixt(1);
}

int main()
{
    signal(14, handler);
    alarm(3);
    while(1)
    {
        printf("hello fl\n");
        sleep(1);
    }
}

运行代码，确实在3秒后调用了signal函数，退出的原因是有exit函数

在中途取消闹钟：

int main()
{

    alarm(20);
    while(1)
    {
        printf("hello fl\n");
        sleep(5);
        int res = alarm(0);
        printf("res: %d\n", res);
    }
}

4.4 硬件异常产生信号

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

总结：信号产生的方式种类虽然非常多，但是无论产生信号的方式千差万别，但是最终，一定都是通过OS向目标进程发送信号的！！！

5、信号的保存与发送

信号的其他相关概念：

• 实际执行信号的处理动作称为信号递达(Delivery)
• 信号从产生到递达之间的状态,称为信号未决(Pending)
• 进程可以选择阻塞 (Block )某个信号
• 被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作
• 注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作

5.1 信号的发送过程

1. PCB进程控制块中函数有信号屏蔽状态字和信号未决状态字，还有是否忽略标志
2. 向进程发送SIGINT，内核首先判断信号屏蔽状态字是否阻塞，若阻塞,信号未决状态字(pending)相应位制成1；若阻塞解除，信号未决状态字(pending)相应位制成0；表示信号可以递达
3. block状态字用户可以读写，pending状态字用户只能读；这是信号设计机制

5.2 信号在内核中的表示

信号在内核中的示意图：

block表和pending表都是用位图来表示信号的状态，block表的0/1表示该信号是否被阻塞。pending表的0/1表示是否未决(已经处理)

block表：代表产生的信号是否要被阻塞(屏蔽)；
pending表：代表是否有产生的信号处于未决状态，当信号由未决状态变到递达时，相应的位图由1变为0；
handler表：储存函数指针的数组，代表了信号的处理方式(默认，忽略，自定义)

每个信号都有两个标志位分别表示阻塞(block)和未决(pending),还有一个handler(函数指针)表示处理动作。信号产生时,内核在进程控制块中设置该信号的未决标志,直到信号递达才清除该标志。
在上图的例子中,SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作。
SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞。
SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler。
如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?POSIX.1允许系统递送该信号一次或多次。Linux是这样实现的:常规信号在递达之前产生多次只计一次,而实时信号在递达之前产生多次可以依次放在一个队列里。

5.3 sigset_t信号集

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

5.4 信号集操作函数

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

#include <signal.h>
int sigemptyset(sigset_t *set);//初始化set所指向的信号集,使其中所有信号的对应bit清零,表示该信号集不包含 任何有效信号
int sigfillset(sigset_t *set);//t初始化set所指向的信号集,使其中所有信号的对应bit都置为1,表示该信号集的有效信号包括系统支持的所有信号
int sigaddset (sigset_t *set, int signo);//把signo信号添加到set所指向的信号集中，也就是signo所对应的bit置为1
int sigdelset(sigset_t *set, int signo);//在set指向的信号集中删除signo信号，也就是signo对对应的bit清0
int sigismember（const sigset_t *set, int signo);//判断signo信号是否在set所指向的信号集中存在

sigismember除外的四个函数都是成功返回0,出错返回-1。sigismember是一个布尔函数,用于判断一个信号集的有效信号中是否包含某种信号,若包含则返回1,不包含则返回0,出错返回-1

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

5.5 block表系统调用接口sigprocmask()

调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集)

如果oset是非空指针,则读取进程的当前信号屏蔽字通过oset参数传出。如果iset是非空指针,则更改进程的信号屏蔽字,参数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解除了对当前若干个未决信号的阻塞,则在sigprocmask返回前,至少将其中一个信号递达

5.6 用sigpending()读取pending表当前进程未决信号集

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

5.7 代码演示

int main()
{
    sigset_t iset;//定义信号集对象
    sigemptyset(&iset);//初始化
    sigaddset(&iset, 2);//将2号信号添加到set中
    sigprocmask(SIG_SETMASK, &iset, NULL);//屏蔽2号信号

    while(1)
    {
        printf("hello fl\n");
        sleep(1);
    }

运行代码：

因为2号信号被屏蔽了，所以按ctrl c 没有任何反应，所以最终只能按ctrl \ 终止进程

再看这样一段代码：先将2号信号屏蔽，10s时再解除对2号信号的屏蔽，中间一直打印pending信号集，当我们给该进程发送2号信号时，最终可以看见在pending信号集中2号信号所对应的bit由0变为1，再变为0的过程

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


//打印pending表
void show_pending(sigset_t *set)
{
  int sig = 1;
  for(; sig<=31; sig++){
    if(sigismember(set, sig)){
      printf("1");
    }
    else 
    {
      printf("0");
    }
  }
  printf("\n");
}

void handler(int sig)
{
  printf("get a sig: %d\n", sig);
}

int main()
{
  signal(2, handler);//对2号信号进行捕捉
  sigset_t pending; 
  sigset_t iset,oset;
  sigemptyset(&iset);
  sigemptyset(&oset);
  
  sigaddset(&iset, 2);//将2号信号添加到iset信号集中
  
  sigprocmask(SIG_SETMASK, &iset, &oset);//屏蔽2号信号
  
  int count = 0;
  
  while(1){
    sigemptyset(&pending);//初始化
    sigpending(&pending);//获取pending表的信号集
    show_pending(&pending);//打印pending表的信号集
    sleep(1);
    count++;
    if(count == 10){
      printf("recover sig mask!\n");
      sigprocmask(SIG_SETMASK, &oset, NULL);//10s解除2对2号信号的屏蔽
    }
  } 
  return 0;
}

6、捕捉信号

前面我们提到过，进程在接受到信号的时候，需要在合适的时候处理。为什么是合适的时候呢？因为信号产生是异步的，当前进程可能在做更重要的事情，因此处理信号时延时处理的(取决于OS和进程)

那什么是合适的时候呢？
这个合适的时候就是信号被递达的时候，一个信号递达，是在内核态切换回用户态时，进行信号的相关检测
内核态：执行OS的代码和数据时，计算机所处的状态叫做内核态
用户态：执行是用户代码和数据时，计算机所处的状态叫做用户态
区别：内核拥有更高的权限

上图很好的说明了信号捕捉时用户态和内核态的切换（用户处理信号最好的时机是程序从内核态切换至用户态的时候），下面就上图的一系列操作作以解释说明：

1. 用户程序注册了SIGQUIT信号的处理函数sighandler（自定义信号处理函数）。
2. 当前正在执行main函数，这里发生中断、异常或者系统调用切换至内核态。
3. 在中断处理完毕后要返回用户态的main函数之前，检查到有信号SIGQUIT递达。
4. 内核决定返回用户态后不是恢复main函数的上下文信息继续执行，而是执行sighandler函数，sighandler函数和main函数使用不同的堆栈空间，两者之间不存在调用和被调用的关系，属于两个独立的控制流程。
5. sighandler函数返回后自动执行特殊的系统调用，调用return再次进入内核态。
6. 如果没有新的信号要递达，这次再返回用户态就是恢复main函数的上下文继续向下执行。

7、信号捕捉函数sigaction

sigaction与signal的作用是一样的，都是信号捕捉函数，只是sigaction的功能更加的丰富，因为考虑了实时信号

void handler(int signo)
{
	printf("get a signo: %d\n", signo);
}

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

	//本质是修改当前进程的handler函数指针数组中特定的内容
	sigaction(2, &act, NULL);

	while(1)
	{
		printf("hello fl\n");
		sleep(1);
	}
	return 0;
}

运行代码：

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

8、可重入函数与不可重入函数

• 可重入函数也可以这样理解，重入即表示重复进入，首先它意味着在这个函数任意时刻都可以被中断，转入OS调度下去执行另外一段代码，而返回控制时不会出现什么错误，其次意味着它除了使用自己栈上的变量以外不依赖于任何环境(包括static)，这样的函数就是purecode(纯代码)可重入，可以允许有该函数的多个副本在运行，由于它们使用的是分离的栈，所以不会互相干扰。如果确实需要访问全局变量(包括static)，一定要注意实施互斥手段。可重入函数在并行运行环境中非常重要，但是一般要为访问全局变量付出一些性能代价
• 在实时系统的设计中，经常会出现多个任务调用同一个函数的情况。如果这个函数不幸被设计成为不可重入的函数的话，那么不同任务调用这个函数时可能修改其他任务调用这个函数的数据，从而导致不可预料的后果。那么什么是可重入函数呢?所谓可重入函数是指一个可以被多个任务调用的过程，任务在调用时不必担心数据是否会出错。不可重入函数在实时系统设计中被视为不安全函数。

保证函数可重入性的方法：

1).在函数体内不访问那些全局变量，不使用静态局部变量，坚持只使用局部变量，写出的函数就将是可重入的。
2).如果必须访问全局变量，记住利用互斥信号量来保护全局变量。

满足下列条件的函数多数是不可重入(不安全)的：

1. 函数体内使用了静态的数据结构。
2. 函数体内调用了malloc()或者free()函数。
3. 函数体内调用了标准I/O函数。

Linux中常见的可重入函数

9、volatile关键字

• volatile的本意是“易变的” 因为访问寄存器要比访问内存单元快的多,所以编译器一般都会作减少存取内存的优化，但有可能会读脏数据。当要求使用volatile声明变量值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。精确地说就是，通过这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问；如果不使用valatile，则编译器将对所声明的语句进行优化
• volatile 作用：保持内存的可见性，告知编译器，被该关键字修饰的变量，不允许被优化，对该变量的任何操作，都必须在真实的内存中进行操作

看这样一段代码：

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

int flag = 0;

void handler(int signo)
{
    flag = 1;
    printf("change flag 0 to 1\n");
}

int main()
{
    signal(2, handler);

    while(!flag);
    printf("这个进程是正常退出的!\n");
    return 0;
}

运行代码，程序进入死循环，按 ctrl c 终止程序

如果我们使用-O3优化级别对代码进行优化，然后再运行代码：

我们发现按 ctrl c 并没有反应，最终还是按 ctrl \ 终止程序，为什么会这样呢？
因为编译器会对flag做检测，判断是否会被修改。在编译器的角度，main函数为一个执行流，在main执行流中，没有对flag进行修改，虽然可能会对2号信号进行捕捉，从而修改flag，但是编译器并不知道，所有就认为flag并不会被修改。为了提高代码的运行效率，从而将flag变量的值拷贝到了寄存器中。
代码运行后，我们按下了 ctrl c，内存中的flag会由0变为1，但是寄存器中的flag值并没有发生改变，永远是0，所以无法终止循环

当我们用volatile关键字修饰flag，再运行代码：

11、SIGCHLD信号（17号）

子进程退出，父进程可以通过阻塞或非阻塞的方式等待子进程结束，然后清理资源，但是不管是那种方式，程序的实现都是比较复杂的有什么办法可以让父进程不用等待，又不会产生僵尸进程呢？

可以让子进程退出时，给父进程发送一个信号，父进程只需要在信号执行函数中调用wait函数清理资源，这样父进程就不必去检测子进程是否退出的问题了

• 进程终止时，会给父进程发送SIGCHLD信号（17号信号）
  我们可以通过代码验证发送的确实是17号信号：

void Getchild(int signo)
{
	printf("get a signal: %d\n", signo, getpid());
}

int main()
{
	signal(SIGCHLD, Getchild);
	pid_t id = fork();
	if(id == 0)
	{
		//child
		int cnt = 5;
		while (cnt)
		{
			printf("我是子进程： %d\n", getpid());
			sleep(1);
			cnt--;
		}
		exit(0);		
	}
	sleep(7);
	return 0;
}

• 父进程如果通过signal或sigaction设置忽略这个信号，子进程终止时自动释放自己的资源，父进程不必再等待子进程(linux下可用，不保证其它系统上可用)，或者自定义SIGCHLD信号处理动作，调用wait等资源释放函数，也可以完成子进程资源的释放。

代码演示：

int main()
{
	signal(SIGCHLD, SIG_IGN);
	pid_t id = fork();
	if(id == 0)
	{
		//child
		int cnt = 5;
		while (cnt)
		{
			printf("我是子进程： %d\n", getpid());
			sleep(1);
			cnt--;
		}
		exit(0);
		
	}
	sleep(7);
	return 0;
}