【Linux】进程信号

1. 信号的理解

1.1 什么是进程信号

当涉及到Linux操作系统中的进程通信和控制时，信号（signal）是一个重要概念，它通常用于在进程之间传递通知和控制信息。
信号可以被认为是一种异步通信机制，它允许一个进程向另一个进程发送一个特定的信号，并且接收进程可以采取适当的行动来相应该信号。进程可以发送信号给其他进程，也可以发送信号给自己。

1.2 见见进程信号

Linux操作系统中提供了许多不同的信号。

• 每个信号都有一个编号和一个宏定义名称，这些宏定义可以在signal.h中找到
• 编号1到31的是普通信号，34到64的是实时信号。
  

常见的，我们在命令行中可以使用信号来杀死进程

或者，我们也可以在前台进程运行时给其发送信号。在进程运行时，按下ctrl+c，就可以终止它了。

1.3 信号的发送与记录

信号的发送

发送信号的本质就是修改进程PCB中的信号位图。PCB是内核维护的数据结构对象，PCB中保存了进程的信息。PCB的管理者是OS，所以也就只有OS才能修改PCB的内容。不管信号发送的方式是怎样的，本质都是通过OS向目标进程发送信号！ 这样的话，OS就必须要提供发送信号处理的相关系统调用，其实我们在命令上输入的kill命令，本质上也是调用了对应的系统调用接口！

信号的记录

上面提到，信号的发送即操作系统修改进程的PCB中的某一个位图，那么信号的记录其实也就是修改PCB中的信号位图的比特位的值。
下图中我们用一个32位的位图来记录信号是否接收到了信号，其中比特位的位置表示信号的编号，比特位的是否为1表示是否收到对应信号。

1.4 信号的处理

1.4.1 信号的三种处理方式

进程处理信号有三种方式：

1. 执行该信号的默认处理动作。
2. 提供一个信号处理函数，要求内核在处理该信号时切换到用户态去执行这个函数，自定义信号的处理动作也叫做信号的捕捉。
3. 忽略该信号。

我们可以使用man手册查看信号的默认处理动作


从图中可以看到信号的Aciton有些是Term，有些是Core。它们虽然都代表着终止进程，但是Core在终止进程的时候会进行一个动作，那就是核心转储。

1.4.2 核心转储

核心转储是什么？

核心转储（Core Dump）是指在程序发生错误或者崩溃时，将程序在运行时的内存状态及相关信息保存到一个文件中的过程。核心转储文件可以被用于后续的调试和分析，以确定程序崩溃的原因和状态。

在云服务器中，核心转储是被默认关掉的，我们可以使用ulimit -a命令查看当前资源限制的设定。

从第一行我们可以看到，核心转储的文件大小为0，表示其是被关闭的。
我们可以使用ulimit -c size设置核心转储文件的大小

core文件的大小设置完之后，就相当于打开了核心转储。当某一个进程运行时，我们使用ctrl+\命令，就相当于发出了有核心转储功能的三号信号。下面我们进行演示。

可以发现，进程在终止之后会显示core dumped，并且在当前路径下会生成一个core文件，该文件的后缀为发生核心转储的进程的PID。

核心转储有什么用？

当我们的代码出错了，我们需要知道出错的原因。如果此时代码运行结束，我们可以根据进程退出码判断代码出错的原因，而如果此时代码没有运行结束，我们是如何判断出错的原因呢？利用核心转储！
通过核心转储的功能，在程序出错之后在当前目录下会生成一个core.pid的文件，这个文件中保存了进程的运行状态及相关信息。

核心转储的使用

在程序出错之后利用可以使用调试器和core文件来查明错误原因，这种调试方式叫做事后调试。
下面用代码进行演示：

运行结果如下：

此时磁盘中生成了core文件

然后使用gdb堆可执行程序进行调试，在gdb中使用core-file core.pid就可以加载core文件，这样就可以得知进程在结束时收到了什么信号，也可以定位到产生该错误的具体代码了。

父进程可使用status变量得知子进程是否进行了核心转储

进程等待waitpid函数的第二个参数status，可以用它来获取子进程的退出状态，当进程异常时，它的比特位代表的信息是这样的。
它的第八位比特位是core dump标准，表示进程退出时是否发生了核心转储。
下面用一段代码啦进行演示：

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>

int main()
{
    pid_t id = fork();
    if (id == 0)
    {
        printf("I am child...\n");
        int *p = NULL;
        *p = 100;
        exit(0);
    }
    int status = 0;
    waitpid(id, &status, 0);
    printf("exitCode: %d, signal: %d, coreDump: %d\n",
        (status >> 8) & 0xFF, status & 0x7F, (status >> 7) & 1);
    return 0;
}

运行结果如下：

这就说明了子进程在退出时进行了核心转储。

2. 信号的产生

2.1 终端按键产生信号

在前台进程运行时，我们可以使用 ctrl+c或者ctrl+\ 来终止进程。
用一串小代码来进行演示。

运行如下：
这是ctrl+c终止进程，其实是发送了二号信号

这是ctrl+\终止进程，其实是发送了三号信号

2.2 系统调用产生信号

在命令行中，可以使用kill命令杀死进程

实际上，这个kill命令就被bash解析为了调用kill函数

kill函数

kill函数的第一个参数为进程pid，第二个参数为信号的编号。
如果函数调用成功，返回0，否则返回-1。

raise函数

raise函数是向当前进程发送信号，也就是自己给自己发送信号。
调用成功返回0，否则返回一个非0值。

abort函数

它是一个无参无返回值的函数，它可以给进程发送SIGABRT信号，使得进程异常终止。
在使用这个函数时，不管你有没有对它的执行动作进行自定义，它都会终止进程，当然，如果自定义了，会调用自定义的函数再终止进程。且abort函数的作用是异常终止进程，exit函数的作用是正常终止进程，而abort函数本质是通过向当前进程发送SIGABRT信号而终止进程的，因此使用exit函数终止进程总是成功的。

2.3 软件异常产生信号

软件异常会产生信号，下面举SIGPIPE和SIGALRM的例子。

SIGPIPE

SIGPIPE信号实际上就是一种由软件条件产生的信号，当进程在使用管道进行通信时，如果读端进程将读端关闭，而写端进程还在一值向管道写入数据，那么写端进程就会收到SIGPIPE信号进而被操作系统终止。

SIGALRM

调用alarm函数可以设定一个闹钟，也就是高速操作系统在若干时间后发送SIGALRM信号给当前进程。

alarm函数的作用就是，让操作系统在seconds秒之后给当前进程发送SIGARM信号，SIGALRM信号的默认处理动作是终止进程。
alarm函数的返回值：

• 若调用alarm函数前，进程已经设置了闹钟，则返回上一个闹钟时间的剩余时间，并且本次闹钟的设置会覆盖上一次闹钟的设置。
• 如果调用alarm函数前，进程没有设置闹钟，则返回值为0。

2.4 硬件异常产生信号

在程序中出现类似于除0，空指针访问，数组越界之类的错误时，CPU会作出标记，操作系统会识别出是哪个进程导致的错误，并将识别到的硬件错误包装成信号发送给目标进程，本质就是操作系统去找到这个进程的PCB，并向PCB中的信号位图写入指定的信号。

比如除0时


操作系统会识别到对空指针解引用的问题，然后对进程发出信号杀死进程。

3. 信号的保存

3.1 信号其他相关概念

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

3.2 信号在内核中的表示

1. 在block位图中，比特位的位置代表某一个信号，比特位的内容代表该信号是否被阻塞
2. 在pending位图中，比特位的位置代表某一个信号，比特位的内容代表是否收到该信号
3. handler表本质是一个函数指针数组，数组的下标代表某一个信号，数组的内容代表该信号抵达时的处理动作，处理动作包括默认，忽略以及自定义。
4. block，pending和handler这三张表的每一个位置是一一对对应的。

参考上面那张图，我作出以下解释：

• 每个信号都有两个标志位表示阻塞（block）和未决（pending），还有一个函数指针（handler）表示处理动作。信号产生时，内核在进程PCB中设置该信号的未决标志，直到信号抵达才清除该标志。在上图中，SIGHUP信号未阻塞也未产生过，当它抵达时执行默认动作。
• SIGINT信号产生过，但正在被阻塞，所以暂时不能抵达。虽然它的处理动作是忽略，但是在没有解除阻塞之前不能忽略这个信号，因为进程仍有机会在改变处理动作之后再解除阻塞。
• SIGQUIT信号未产生过，但一旦产生SIGQUIT信号，该信号将被阻塞，它的处理动作是用户自定义函数sighandler。

3.3 sigset_t类型

未决和阻塞标志用相同的数据类型sigset_t来存储。
sigset_t定义如下：（不同的操作系统可能不同）

#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{
	unsigned long int __val[_SIGSET_NWORDS];
} __sigset_t;

typedef __sigset_t sigset_t;

sigset_st就称为信号集，这个类型可以表示信号的有效和无效状态

• 在阻塞信号集中有效和无效的含义是该信号是否被阻塞
• 在未决信号集中有效和无效的含义是该信号是否处于未决状态

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

3.4 信号集操作函数

可以使用一下函数来操作sigset_t变量

对于这些函数有以下解释：

• sigemptyset函数：初始化set所指向的信号集，使其中所有信号的对应bit位置为0，表示该信号集不含有任何有效信号。调用成功返回0，否则返回-1。
• sigfillset函数：初始化set所指向的信号集，使其中所有信号对应的bit位置为1，表示该信号集的有效信号包含该系统的所有普通信号。调用成功返回0，否则返回-1。
• sigaddset函数：在set指向的信号集中添加某种有效信号。调用成功返回0，否则返回-1。
• sigdelset函数：在set指向的信号集中删除某种有效信号。调用成功返回0，否则返回-1。
• sigismember函数：判断set指向的信号集中是否包含某种信号，若包含返回1，不包含返回0，调用失败返回-1。

3.5 sigprocmask函数

它可以用来查看或者修改进程的信号屏蔽字（或者说阻塞信号集）。

参数说明：

• 如果oldset为非空指针，则读取当前进程的信号屏蔽字通过oldset传出
• 如果set为非空指针，则更改当前进程的信号屏蔽字，参数how为如何修改
• 如果oldset和set都为非空指针，则将原来的信号屏蔽字备份到oldset中，然后根据set和how参数更改信号屏蔽字

假设当前进程的信号屏蔽字为mask，下面说明了how参数的选项及意义：

• SIG_BLOCK：set包含了我们希望添加到当前信号屏蔽字的信号，相当于mask = mask | set
• SIG_UNBLOCK：set包含了我们系统从当前信号屏蔽字中解除阻塞的信号，相当于mask | ~set
• SIG_SETMASK：设置当前信号屏蔽字为set所指向的值，相当于mask = set

如果该函数调用成功返回0，调用失败返回-1。

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

3.6 sigpending函数

sigpending函数可以用来读取进程的未决信号集
读取当前进程的未决信号集，并通过set参数传出。函数调用成功返回0，除草返回-1。

4. 信号的捕捉

4.1 内核空间和用户空间

每一个进程都有自己的进程地址空间，该进程地址空间由内核空间和用户空间组成：

• 用户所写的代码和数据位于用户空间，用过用户级页表与物理内存之间建立映射关系
• 内核空间存储的实际上是操作系统的代码和数据，通过内核级页表与物理内存之间建立映射关系

内核级页表是一个全局的页表，它用来维护操作系统的代码和进程之间的关系。因此，在每个进程的进程地址空间中，用户空间是属于当前进程的，每个进程看到的代码和数据是不同的，但内核空间所存放的都是操作系统的代码和数据，所有进程看到的都是一样的内容。

虽然每个进程都能够看到操作系统，但是并不意味着每个进程都能够随时对其进行访问。

如何理解进程程序切换？

• 在当前进程的进程地址空间内的内核空间，找到操作系统的代码和数据
• 执行操作系统的代码，将当前进程的代码和数据剥离下来，并换上另一个进程的代码和数据

当进程访问用户空间时必须处于用户态，当访问内核空间时必须处于内核态。

4.2 内核态与用户态

前面说过，信号产生的时候，信号可能不会立即处理，而是在合适的时候处理。合适的时候就是从内核态返回用户态的时候，这说明了曾经一定是先进入了内核态，最典型的就是系统调用与进程切换。

内核态与用户态：

• 内核态用来执行操作系统的代码，是一种权限非常高的状态
• 用户态是一种用来执行普通用户代码的状态，是一种受监管的普通状态

内核态和用户态之间是如何进行切换的？

从用户态切换到内核态通常有以下几种情况：

1. 需要进行系统调用
2. 当前进程的时间片到了，导致进程切换
3. 产生异常、中断、陷阱等

从内核态切换到用户态有以下几种情况：

1. 系统调用返回
2. 进程切换完毕
3. 异常、中断、陷阱等处理完毕。

其中，由用户态切换为内核态我们称陷入内核。每当我们需要陷入内核时，本质上是因为我们需要执行操作系统的代码，比如系统调用函数是由操作系统实现的，我们系统进程系统调用时就要先陷入内核。

4.3 信号的捕捉函数

信号的捕捉是指程序通过注册信号处理程序来相应特定信号的过程。

signal函数

第一个参数为要进行捕捉的信号编号
第二个参数为一个函数指针，信号在被捕捉之后，它在被抵达的时候就会执行这个函数。

它的返回值为一个函数指针，对于其返回值的理解：

1. 如果signal函数成功注册了一个信号处理程序，并且之前没有为该信号设置过处理程序，则返回之前的信号处理程序为NULL
2. 如果signal函数成功注册了一个信号处理程序，并且之前为该信号设置过处理程序，则返回之前的信号处理程序地址
3. 如果signal函数执行失败，则返回SIG_ERR，这是一个特殊的宏定义，表示发生了错误

下面一串代码用于理解这个函数

将程序运行起来，结果如下：

可以看到，在每次我们ctrl+c的时候，进程并没有被终止，而是去执行我们的自定义动作。

注意：sighandler和main函数使用不同的堆栈空间，它们之间不存在调用和被调用的关系，是两个独立的控制流程。

sigaction函数

捕捉信号除了使用signal函数，也可以使用sigaction函数。

sigaction可以读取和修改与指定信号相关联的动作，调用成功返回0，出错返回-1。
参数说明：

• signum表示指定的信号编号
• 若act指针非空，则根据act修改该信号的处理动作
• 若oldact指针非空，则通过oldact传出该信号原来的处理动作

act和oldact都是结构体变量，该结构体定义如下：

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

结构体的第一个成员sa_handler

• 将sa_handler赋值为常数SIG_IGN传给sigaction函数，表示忽略信
• 将sa_handler赋值为常数SIG_DEL传给sigaction函数，表示执行系统默认动作
• 将sa_handler赋值为一个函数指针，表示用自定义函数捕捉信号，或者说向内核注册了一个信号处理函数

注意：所注册的信号处理函数的返回值为void，参数为int，通过参数可以得知当前信号的编号，这样就可以用同一个函数处理多种信号。显然这是一个回调函数，它不是被main函数调用，而是被系统所调用。

结构体第二个成员sa_sigaction

sa_sigaction是实时信号的处理函数

结构体的第三个成员sa_mask

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

结构体的第四个成员sa_flags

sa_flags字段中包含一些选项，这里直接将sa_flags设置为0即可。

结构体的第五个成员sa_restorer

这个成员通常不被使用

下面我们用代码进行演示，用sigaction函数对2号信号进行捕捉，将2号信号的处理动作改为了自定义的打印动作，并在执行一次自定义动作后将2号信号的处理动作恢复为原来的默认动作。

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

struct sigaction act, oact;
void handler(int signo)
{
	printf("get a signal:%d\n", signo);
	sigaction(2, &oact, NULL);
}
int main()
{
	memset(&act, 0, sizeof(act));
	memset(&oact, 0, sizeof(oact));

	act.sa_handler = handler;
	act.sa_flags = 0;
	sigemptyset(&act.sa_mask);

	sigaction(2, &act, &oact);
	while (1){
		printf("I am a process...\n");
		sleep(1);
	}
	return 0;
}

运行结果如下：

可以看到，当我们第一次向进程发送2号信号，执行我们自定义的打印动作，当我们再次向进程发送2号信号，就执行该信号的默认处理动作了，即终止进程。

4.4 信号抵达的过程

当我们在执行主控制流程的时候，可能会因为某些情况陷入内核，当内核处理完毕准备返回用户态时，就需要进行信号pending的检查。（此时仍处于内核态，有权力检查当前进程的pending图）
在查看pending位图时，如果发现有未决信号且该信号没有被阻塞，那么此时就需要对该信号进行处理。
如果待处理的信号的处理动作是默认或者忽略，则执行该信号的处理动作之后清除对应的pending位即可。
在抵达完毕之后，如果没有新的信号要抵达，就直接返回用户态，从主控制流程中上次被中断的地方继续向下执行即可。

但是如果待处理信号是自定义捕捉的，即该信号的处理动作是由用户提供的，那么处理该信号时就需要先返回用户态执行对应的自定义处理动作。
执行完之后再通过特殊的系统调用sigreturn再次陷入内核并清除对应的pending标志位，如果没有新的信号要抵达，就直接返回用户态，继续执行主控制流程的代码。

当信号的处理为自定义动作时，可以形象地记忆为下图。

其中，该图形与直线有几个交点就代表在这期间有几次状态切换，而箭头的方向就代表着此次状态切换的方向，图形中间的圆点就代表着检查pending图。

当识别到信号的处理动作是自定义时，能直接在内核态执行用户的代码吗？

理论上是可以的，因为内核态是一种权限非常高的状态，但是我们不能这样设计！
如果允许直接在内核态执行用于的代码，那么用户就可以在代码中设计一些非法操作，比如清空数据库等，虽然在用户态时没有足够的权限做到清空数据库，但是如果在内核态执行了这种非法代码，数据库就真的被清空了，因为内核态是有足够权限清空数据库的。
也就是说，不能让操作系统直接去执行用户的代码，因为操作系统无法保证用户的代码是合法代码，即操作系统不信任任何用户。

5. 不可重入函数

情景是这样的，主函数调用insert函数向链表中插入节点node1，某信号处理函数也调用了insert函数向链表中插入节点node2，然后就会出现一些问题。

下面我们分析一下这个链表的插入情况

1.首先，main函数中调用了insert函数，函数是要将node1节点插入链表，插入操作分为两步，刚做完第一步的时候，可能因为某些原因发生中断，切换到了内核，再次回到用户态之前检查到了有信号需要被处理，于是就切换到了sighandler函数。

2.而sighandler函数中也调用了insert函数，将节点node2插入到链接中


在两步操作都完成之后才切回到内核态

3.再次回到内核态之后就从main函数调用的insert函数继续向下执行，即进行插入node1节点的第二步操作

最终结果是，main函数和sighandler函数都向链表中插入了节点，但最后只有node1节点真正插入到了链表中，造成了内存泄漏的问题。

像上面这样，insert函数被不同的控制流调用（main函数和sighandler函数使用不同的堆栈空间，它们之间不存在调用和被调用的关系，是两个独立的控制流程），有可能在第一次调用还未结束时就再次进入该函数，我们将这种现象称为为重入。

而insert函数访问一个全局链表，有可能因为重入而造成错乱，像这样的函数我们称之为不可重入函数，反之，如果一个函数只访问自己的局部变量或参数，则称之为可重入函数。

如果一个函数符合以下条件之一则是不可重入的：

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

6. volatile关键字

volatile是C语言的一个关键字，该关键字的作用是保持内存的可见性。

在下面的代码中，我们对2号信号进行了捕捉，当该信号收到2号信号时会将全局变量flag由0置为1。也就是说，在进程收到2号信号之前，该进程会一直处于死循环状态，直到收到2号信号时将flag置1才能够正常退出。

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

int flag = 0;

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

int main()
{
    signal(2, handler);
    while (!flag);
    printf("proc normal quit!\n");
    return 0;
}

运行结果如下：

此时没有什么问题。

但是代码中的main函数和handler函数是两个独立的执行流，而while循环是在main函数当中的，在编译器编译时只能检测到mian函数对flag变量的使用。此时编译器检测到在main函数中并没有对flag变量做修改操作，在编译器优化级别较高的时候，就有可能将flag设置进寄存器里面。

此时main函数在检测flag时只会检测寄存器内的值，而handler执行流只是将内存中flag的值置为1了，并不会影响main函数中对flag的使用。

在编译代码时带上 -O3 选项使得编译器的优化级别最高，此时再运行该代码，就算向进程发送2号信号，该进程也不会终止。

面对这种情况，我们就可以使用volatile关键字对flag变量进行修饰，告诉编译器，对flag的任何操作都必须在内存中进行，即保持了内存的可见性。

7. SIGCHLD信号

为了避免出现僵尸进程，父进程需要使用wait或者waitpid函数等待子进程结束。父进程可以阻塞等待子进程结束，也可以非阻塞地查询是否有子进程结束等待清理，即轮询的方式。采用第一种方式，父进程阻塞就不能处理自己的工作了；采用第二种方式，父进程在处理自己工作的同时还要查看是否有子进程等待回收，程序实现复杂。

其实，子进程在终止时会给父进程发送SIGCHLD信号，该信号的默认处理动作是忽略，父进程可以自定义SIGCHLD信号的处理动作，这样父进程就只需专心处理自己的工作，不必关心子进程了，子进程终止时会通知父进程，父进程在信号处理函数中调用wait或waitpid函数清理子进程即可。

例如，下面代码中对SIGCHLD信号进行了捕捉，并将在该信号的处理函数中调用了waitpid函数对子进程进行了清理。

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/wait.h>

void handler(int signal)
{
    printf("get a signal: %d\n", signal);
    int ret = 0;
    while (ret = waitpid(-1, NULL, WNOHANG) > 0)
    {
        printf("wait child %d success\n", ret);
    }
}

int main()
{
    signal(SIGCHLD, handler);
    if (fork() == 0)
    {
        printf("child is running, pid: %d\n", getpid());
        sleep(3);
        exit(0);
    }

    while (1);
    return 0;
}

注意：

1. SIGCHLD属于普通信号，记录该信号的pending位只有一个，如果在同一时刻有多个子进程同时退出，那么在handler函数当中只清理了一个子进程，因此在使用waitpid函数清理子进程时需要使用while不断进行清理。
2. 使用waitpid函数时，需要设置WNOHANG选项，即非阻塞式等待，否则当所有子进程都已经清理完毕时，由于while循环，会再次调用waitpid函数，此时就会一直阻塞。

这样一来，父进程就只需要专心处理自己的工作，不必关心子进程了，子进程在终止时父进程收到SIGCHLD信号，会自动进行该信号的自定义处理动作，进而对子进程进行清理。

要想不产生僵尸进程还有另外一种办法：父进程调用signal或sigaction函数将SIGCHLD信号的处理动作设置为SIG_IGN，这样fork出来的子进程在终止时会自动清理掉，不会产生僵尸进程，也不会通知父进程。系统默认的忽略动作和用户使用sigal或sigaction函数自定义的忽略通常是没有区别的。但是这种方法只对于Linux可用，在其他UNIX系统中不一定可用。

下面代码中调用sigal函数将SIGCHLD信号处理动作设置为忽略

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

int main()
{
    signal(SIGCHLD, SIG_IGN);
    if (fork() == 0)
    {
        printf("child is running, pid: %d\n", getpid());
        sleep(3);
        exit(0);
    }

    while (1);
    return 0;
}

这样子进程就会在终止时自动被回收，不会产生僵尸进程，也不会通知父进程。