目录
9号信号：管理员信号，该信号不可被自定义设置(捕捉)。除了D状态进程，其他进程都可杀。SIGSTOP(19号信号)/SIGKILL(9号信号)信号无法被阻塞，无法被自定义，无法被忽
②9号信号不可被捕捉，6号信号是可以被捕捉，但捕捉完还是要退出
（3）优化+volatile 情况（有-O2优化，有volatile）
（4）volatile关键字可以保证并发编程中的可见性，有序性。
1.子进程在 终止/暂停（stop）/继续运行时 会给父进程发SIGCHLD信号（ctrl+z是19号信号-暂停进程）
（2）进程 暂停（stop）/继续运行 会发信号（ctrl+z是19号信号-暂停进程）
（4）将SIGCHLD的处理动作置为SIG_IGN——自动释放子进程
一.信号入门
1.信号是操作系统内一个内置机制
信号是给进程发送的，进程要具备处理信号的能力。
1.该能力一定是预先已经早就有了的（程序员——>写OS的代码，OS帮我们提供）
2.进程能够识别对应的信号
3.进程能够处理对应信号
对于进程来讲，即便是信号还没有产生，我们进程已经具有识别和处理这个信号的能力了，因为信号是操作系统内一个内置的机制。
2.前后台进程的几条命令与ctrl+c，Ctrl+z
- 前台进程：占有控制终端的进程，其它称为后台进程。前台进程可以ctrl+c杀掉，后台进程不可杀，只能把后台进程转成前台进程再ctrl+c杀掉。
Ctrl+c是强制中断程序的执行，杀死程序的进程；
Ctrl+z是将任务中断，挂起的状态，进程还存在，任务还没有结束，用户可以通过使用fg命令将中断的命令再次启动运行；
ctrl+c：硬件行为被解释成信号，发送给进程。作用：杀死进程
jobs：查看后台进程
./proc &：把proc这个前台进程放入后台
fg (任务号)：把作业号对应的后台进程放入前台
3.信号分类
1~31：普通信号（我们要学习的信号）也叫不可靠信号。 34~64：实时信号(带RM) 【34】SIGRTMIN（实时信号也叫可靠信号）
普通信号介绍：1) SIGHUP ——>1是信号的编号，SIGHUP是信号名称。信号就是宏，SIGHUP的值就是1
查看详细信号命令
man 7 signal
4.信号产生是异步的
因为信号产生是异步的（互不干扰，同步反义词），当信号产生的时候，对应的进程可能正在做更重要的事情，我们进程可以暂时不处理这个信号!——进程可能不需要立即处理这个信号。不代表这个信号不会被处理
未来要处理，所以你必须记住这个信号已经来了(要记住：①是否有信号。②什么信号。 )（你在玩游戏，外卖员敲门，你说等一会儿）
①默认动作（吃外卖）
②忽略（把外面放在外卖，不吃）
③自定义动作（把外卖给弟弟吃）
这就是类比了信号的处理，信号的捕捉，递达处理动作。
5.进程是如何记住这个信号
（1）要存储的内容：
① 有没有产生【位图比特位的内容1,0】
② 什么信号产生【位图比特位的位置】
（2）存储在哪里：信号内容记录在 进程的PCB中的
（3）存储方式：位图
task_ struct {
uint32_ _t sig; 位图，0000 0010
}
进程的task_ struct是内核的数据结构
只有OS有这个权利，能直接修改这个task_struct内的数据位图
OS是进程的管理者，进程的所有属性的获取和设置，只能由OS来。
无论信号怎么产生，最终一定只能是OS帮我们进行信号的设置!
二.signal ——对某信号设置自定义行为(捕捉)的函数
man 2 signal
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
signum：对哪个信号设置捕捉动作。 handler：自定义对信号的捕捉动作的函数
（1）证明 ctrl + c 是2号信号
这里不是调用hander方法，这里只是设置了一个回调（注册这个方法），让SIGINT(2)产生的时候，该方法才会被调用，如果不产生SIGINT(2)，该方法不会被调用！
ctrl + c : 本质就是给前台进程发送2号信号给目标进程，目标进程默认对2号信号的处理，是终止自己
今天更改了对2号信号的处理，设置了用户自定义处理方法
void handler(int signo)
{
cout << "我是一个进程，刚刚获取了一个信号: " << signo << endl;
}
int main()
{
//这里不是调用hander方法，这里只是设置了一个回调，让SIGINT(2)产生的时候，该方法才会被调用
//如果不产生SIGINT(2)，该方法不会被调用！
//ctrl + c : 本质就是给前台进程发送2号信号给目标进程，目标进程默认对2号信号的处理，是终止自己
//今天更改了对2号信号的处理，设置了用户自定义处理方法
signal(SIGINT, handler); // 设置所有的信号的处理动作，都是自定义动作
while (true)
{
cout << "我是一个正在运行中的进程: " << getpid() << endl;
sleep(1);
}
return 0;
}
（2）ctrl+\：3号信号 ——默认也是终止自己
void handler(int signo)
{
cout << "我是一个进程，刚刚获取了一个信号: " << signo << endl;
}
int main()
{
signal(SIGINT, handler); // 设置所有的信号的处理动作，都是自定义动作
signal(3, handler);
while (true)
{
cout << "我是一个正在运行中的进程: " << getpid() << endl;
sleep(1);
}
return 0;
}
这个进程里面自定义这些终止信号后，就只能用9号信号杀死。
9号信号：管理员信号，该信号不可被自定义设置(捕捉)。除了D状态进程，其他进程都可杀。SIGSTOP(19号信号)/SIGKILL(9号信号)信号无法被阻塞，无法被自定义，无法被忽
（3） 一个进程无法被kill杀死的可能有哪些
A①这个进程阻塞了信号
B②用户有可能自定义了信号的处理方式
C③这个进程有可能是僵尸进程
D④这个进程当前状态是停止状态
A正确 信号被阻塞，则暂时不被处理（SIGKILL/SIGSTOP除外，因为无法被阻塞，这里说的是可能性，因此不做太多纠结）
B正确 自定义处理之后，信号的处理方式有可能不再是进程退出
C正确 僵尸进程因为已经退出，因此不做任何处理
D正确 进程停止运行，则将不再处理信号
三.用户层产生信号的方式（信号产生前）
1.敲键盘的信号发送过程
键盘产生信号，OS给进程发送的信号——发送信号(写入信号)：就是OS在位图中把对应信号的位图由0置1，即可完成发送信号(发送信号不如说成写入信号)。详解ctrl+v的信号发送过程：
—敲键盘ctrl+v，键盘产生信号后，通过中断的方式告诉OS，CPU直接调用中断向量表中的方法，把ctrl+v这个组合按键读取进来，OS识别此组合按键，OS对组合按键进行解释，解释成信号，OS找到对应进程，在位图中把对应信号的位图由0置1。
2.通过 系统接口 完成对进程发送信号
（1）kill
man 2 killint kill(pid_t pid, int sig);
向任意进程pid发送任意信号sig
返回值：成功返回0；失败返回-1
自己写一个mykill命令：
（2）raise
man 3 raise给自己这个进程发送任意信号
（3）abort
man 3 abort向自己这个进程发送 SIGABRT 这个6号信号
① abort() = exit()
②9号信号不可被捕捉，6号信号是可以被捕捉，但捕捉完还是要退出
3. 软件条件，定闹钟alarm
alarm
man 2 alarm定闹钟：seconds秒以后给自己这个进程发送信号 14 SIGALRM
①1秒IO只能不到2w次
②但实际CPU 1秒能跑5亿次，证明IO效率低
4.硬件异常产生信号
（1）除零错误 与 越界&&野指针
进程崩溃的本质，是该进程收到了异常信号。
因为硬件异常，而导致OS向目标进程发送信号，进而导致进程终止的现象！
除零错误: CPU内部，状态寄存器，当我们除0的时候，CPU内的状态寄存器会被由0置1，设置成为 有报错：浮点数越界。CPU的内部寄存器(硬件)会记录报错，OS就会识别到CPU内有报错啦 -> 识别之后OS会确认 ①谁干的？② 是什么报错，OS结合报错会构建信号，并向目标进程发送信号->目标进程在合适的时候处理信号，处理一般信号就是终止进程
越界&&野指针: 我们在语言层面使用的地址(指针), 其实都是虚拟地址，虚拟地址要转成物理地址->然后才能访问物理内存->才可以读取对应的数据和代码
如果虚拟地址有问题，因为地址转化的工作是由(MMU(memory maneger unit 内存管理单元，是硬件)+页表(软件))， 转化过程就会引起问题->表现在硬件MMU上->OS发现硬件出现了问题会确认：①谁干的？② 是什么报错(OS->构建信号) -> 向目标进程发送信号->目标进程在合适的时候->处理信号->终止进程
（2）崩溃了，一定会导致进程终止吗？——答：不一定！
例如：我们把信号都重新注册了，但是注册的方法里面没有终止程序(exit)，那么当发生除0错误时，OS给进程发送8号信号，但是由于没有中断进程，这个异常一直存在，OS会持续不断的发送8号进程，此时崩溃了，但是进程也并没有终止
小总结：
——OS将进程PCB中信号位图的比特位由0置1
四.core dump 核心转储
1.status中的core dump标记位
man 7 signal
（1）core dump 核心转储 详细解释：
像3,4,6,8,11这些信号属于代码内部出现问题导致的进程终止（比如4：非法指令。6：abort终止。8：浮点数错误。11：越界。），这些异常可以调试。如果父进程获取子进程退出信息时，若被这几种信号终止，status中的core dump标记位会被置1，并且会生成一个叫 core.22357 的大文件，22357 叫引起core文件(崩溃)的进程pid。
即：core dump 核心转储定义： core dump 会把进程在运行中，对应的异常上下文数据，core dump(转而存储)到磁盘上，方便调试，同时会把status中的 status- >core dump -> 置1
（2）观察core dump标记位
ulimit -a 打开 core dump文件
（3） core可以用gdb定位错误
五.阻塞信号（信号产生中）
1. 信号其他相关常见概念
2. 在内核中的表示
横着看——block—pending—hander横着每一格对应每一格
pending：未决信号集。（用途：代表是否收到信号）就是一个32bit的位图，存信号标记位，比特位位置是信号编号（第一个比特位代表1号信号），比特位内容代表 是否收到信号。（信号产生时,内核在进程控制块中设置该信号的未决标志,直到信号递达才清除该标志。）
【非可靠信号在进行注册时，会查看是否已经有相同信号添加到未决集合中，如果有则什么都不做，因此非可靠信号只会添加一次，因此处理完毕后会直接移除（准确来说是先移除，后处理）。而可靠信号会重复添加信号信息到sigqueue链表中，相当于可靠信号可以重复添加，处理完毕后，因为有可能还有相同的信号信息待处理，因此并不会直接移除，而是检测没有相同信号信息后才会从pending集合中移除】
block：信号屏蔽字（阻塞信号集）。和pending一样的是 比特位位置是信号编号，不同的是 比特位内容代表 是否阻塞该信号——为1：拦截对应信号执行对应的方法，举例：即使pending[0]=1，block[0]=1,1号信号也无法执行hander里面对应的方法（ 阻塞信号集也叫做当前进程的 信号屏蔽字(Signal Mask),这里的“屏蔽”应该理解为阻塞而不是忽略。）
信号忽略和信号阻塞区别：
信号忽略是处理信号的方式，处理方式是忽略他；信号阻塞是拦截信号的递达，不让信号被处理
3.sigset_t（位图）
sigset_t就是一个位图
# define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
typedef struct
{
unsigned long int __val[_SIGSET_NWORDS];
} __sigset_t;4.信号集操作函数
5.sigprocmask
const sigset_t *set 是输入型参数，set传入一个信号集,
如果how是 SIG_BLOCK ：则把set中包含的信号添加到当前进程的信号屏蔽字block表中（block对应标记位由0置1），当前进程的信号屏蔽字中已经屏蔽的信号不会改变。
如果how是 SIG_UNBLOCK：则把set中包含的信号从到当前进程的信号屏蔽字block表中解除屏蔽block对应标记位由1置0），当前进程的信号屏蔽字中其他已经屏蔽的信号不会改变。
如果how是 SIG_SETMASK：直接把用set这个信号集把 当前进程的信号屏蔽字block表 覆盖。
sigset_t *oset 是输出型参数：把原本老的信屏蔽字返回出来，以便恢复，如果不想返回就传nullptr
如果调用sigprocmask解除了对当前若干个未决信号的阻塞,则在sigprocmask返回前,至少将其中一个信号递达。
使用示例：
6.sigpending
总结：sigprocmask修改block表；sigpending读取 pending表；signal修改hander表
#include <iostream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
using namespace std;
int cnt = 0;
void handler(int signo)
{
cout << "我是一个进程，刚刚获取了一个信号: " << signo << " cnt: " << cnt << endl;
// exit(1);
}
static void showPending(sigset_t *pendings)
{
for (int sig = 1; sig <= 31; sig++)
{
if (sigismember(pendings, sig))
{
cout << "1";
}
else
{
cout << "0";
}
}
cout << endl;
}
int main(int argc, char *argv[])
{
cout << "pid: " << getpid() << endl;
sigset_t bsig, obsig;
sigemptyset(&bsig);
sigemptyset(&obsig);
// sigfillset();
for (int sig = 1; sig <= 31; sig++) //将当前进程阻塞所有信号，并注册所有信号
{
sigaddset(&bsig, sig);
signal(sig, handler);
}
// 设置用户级的信号屏蔽字到内核中
sigprocmask(SIG_SETMASK, &bsig, &obsig);
// 1. 不断的获取当前进程的pending信号集
sigset_t pendings;
int cnt = 0;
while (true)
{
// 1.1 清空信号集
sigemptyset(&pendings);
// 1.2 获取当前进程(谁调用，获取谁)的pending信号集
if (sigpending(&pendings) == 0)
{
// 1.3 打印一下刚刚获取到的当前进程的pengding信号集
showPending(&pendings);
}
sleep(1);
cnt++;
if(cnt == 20) //第20秒时解除2号信号的阻塞
{
cout << "解除对2号信号的block...." << endl;
sigset_t sigs;
sigemptyset(&sigs);
sigaddset(&sigs, 2);
sigprocmask(SIG_UNBLOCK, &sigs, nullptr);
}
} 
六.信号的捕捉（信号处理后）
进程处理信号，不是立即处理的。
合适的时候，是什么时候呢? ?——当当前进程从内核态，切换回用户态的时候，进行信号的检测与处理! 先解释用户态和内核态：
1.用户态和内核态
①OS在不在内存中被加载呢? ?——在
无论进程怎么切换，我们都可以找到内核的代码和数据,前提是你只要能够有权利访问!
②当前进程如何具备权利 访问这个内核页表乃至访问内核数据呢?——要进行身份切换。
进程如果是用户态的——>只能访问用户级页表 0~3G
进程如果是内核态的——>访问内核级和用户级的页表 3~4G
③我怎么知道我是用户态的还是内核态的呢?
CPU内部有对应的状态寄存器CR3, CR3有比特位标识当前进程的状态 0:内核态，3:用户态
④0—>3 用户态切到内核态的情况：1.系统调用的时候。2.时间片到了，进程间切换。3.其他等等。执行完毕就继续切回用户态。即：程序运行从用户态切换到内核态的操作：中断/异常/系统调用，例如
<1> 整数除以零操作会导致用户态—>内核态：因为会导致程序异常（分母不能为0）
<2> sin（）函数调用操作不会切换状态，因为库函数并不会引起运行态的切换
<3> read 系统调用操作会导致用户态—>内核态：符合系统调用接口
⑤内核态vs用户态
内核态可以访问所有的代码和数据——内核态具备更高权限
用户态只能访问自己的
⑥我们的程序，会无数次直接或者间接的访问系统级软硬件资源(管理者是OS)，本质上，你并没有自己去操作这些软硬件资源，而是必须通过OS- >无数次的陷入内核(1.切换身份3->0 2.切换页表，切到内核级页表)->调用内核的代码->完成访问的动作->结果返回给用户(1.切换身份0->3 2. 切换页表，切到用户级页表)->用户得到结果
⑦while(1);死循环进程普通程序会身份切换吗？ —>也会陷入内核，来回切换身份 —>你也有自己的时间片 —>时间片到了的时候->OS收到中断信息，把进程从cpu移走，进程切到内核态，更换内核级页表 —>保护上下文，执行调度算法 —>选择了新的进程 —>恢复新进程的上下文 —>用户态，更换成用户级页表 —>CPU执行的就是新进程的代码!
2.自定义捕捉信号的处理过程
①因为一些系统调用例如open()，用户态—>内核态，处理完open的代码后
②本来可以返回代码继续执行了，但是正好处于内核态，就顺便去检测信号，并处理信号。
③处理信号：若是阻塞或无信号(忽略/默认)就直接进行对应简答操作就 内核态—>用户态 返回即可 / 若是非阻塞并有信号的自定义捕捉，就 内核态—>用户态 执行对应的handler方法。（执行handler方法为什么只能是用户态？解释：内核态是什么都可以做的，如果让内核态做用户自定义代码，万一用户写的是一段恶意代码呢? ? ?比如rm根目录等等，这样内核态身份就被恶意利用了，所以内核为了保护自己，就只能用户态执行用户的代码）
④执行完信号对应方法后再由 用户态—>内核态 回到内核。此时所有任务都完成：系统接口调用完成，信号捕捉完成。
⑤完成所有任务后，由 内核态—>用户态 通过特殊系统调用返回到当时用户跳出的代码中。
结论：进程的生命周期中，会有很多次机会去陷入内核(中断，陷阱，系统调用，异常...),一定会存在很多次的机会进行内核态返回用户态。进程的信号在被合适的时候处理，合适的时候：从内核态返回到用户态的时候，返回之前顺便检测信号，并处理信号
过程图，跟上面一样，可以忽略：
记忆图 ：无穷大画法
无穷大中间交点要在横线下方，则有多少个交点，就证明有多少个状态切换；方向决定了 是内核到用户，还是用户到内核
3.第二个捕捉函数 sigaction
（1）sigaction介绍
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
signum：要对哪个信号自定义捕捉。act：设置成什么动作。oldact：老动作，输出型参数，不要就设置nullptr
只用填sa_handler，sa_mask，2个 ，sa_flags 默认为0不考虑，其他是实时信号的也不考虑、
sa_handler：注册信号的函数处理方法
sa_ mask ——作用：执行某①信号处理函数时，信号集位图sa_ mask中有某②信号，阻塞①信号同时，阻塞 sa_ mask 传入的②信号——（2）是详细解释
例1
例2
killall mysignal——根据进程名杀进程
（2）sa_mask 解释
sa_ mask ——作用：执行某①信号处理函数时，信号集位图sa_ mask中有某②信号，阻塞①信号同时，阻塞 sa_ mask 传入的②信号
ctrl c后再ctrl c发现2号信号为1，即：阻塞了2号信号。sigaddset(&act.sa_ mask，3) ; 信号集位图中有3号信号，作用是执行2号信号时阻塞了2号信号同时也阻塞3号信号
（3）handler可以配合使用switch语句：
void Handler2()
{
cout << "hello 2" << endl;
}
void Handler3()
{
cout << "hello 3" << endl;
}
void Handler4()
{
cout << "hello 4" << endl;
}
void Handler5()
{
cout << "hello 5" << endl;
}
void Handler(int signo)
{
switch (signo)
{
case 2:
Handler2();
break;
case 3:
Handler3();
break;
case 4:
Handler4();
break;
case 5:
Handler5();
break;
default:
break;
}
}
int main()
{
signal(2, Handler);
signal(3, Handler);
signal(4, Handler);
signal(5, Handler);
while (1)
{
sleep(1);
}
}4.可重入函数
main函数调用insert函数向一个链表head中插入节点node1,插入操作分为两步,刚做完第一步的 时候,因为硬件中断使进程切换到内核,再次回用户态之前检查到有信号待处理,于是切换 到sighandler函 数,sighandler也调用insert函数向同一个链表head中插入节点node2,插入节点node2操作的 两步都做完之后从 sighandler返回内核态,再次回到用户态就从main函数调用的insert函数中继续 往下执行,先前做第一步，之后被打断,现在继续做完第二步。结果是,main函数和sighandler先后 向链表中插入两个节点,而最后只有一个节点node1真正插入链表中了，node2会内存泄漏。
像上例这样,insert函数被不同的控制流程调用,有可能在第一次调用还没返回时就再次进入该函数,这称为重入,insert函数访问一个全局链表,有可能因为重入而造成错乱,即：不能多个执行流调用，被像这样的函数称为 不可重入函数(大部分都是)。反之, 如果一个函数只访问自己的局部变量或参数，在重复被多个执行流调用时不会出现问题，则称为可重入(Reentrant) 函数。（或者此函数中对全局变量进行了原子操作，也是可重入函数<原子操作指的是一次完成，中间不会被打断的操作，表示操作过程是安全的>）想一下,为什么两个不同的控制流程调用同一个函数,访问它的同一个局部变量或参数就不会造成错乱?
5.volatile
作用：保持内存的可见性，读取必须从内存中读
（1）常规情况（无-O2优化，无volatile）
正常makefile中 不加-O2 也不加volatile 是和(2)一样的结果，都能把flags修改而终止进程。
（2）优化情况（有-O2优化，无volatile）
但是makefile加了-O2，表明让编译器优化：因为while(!flags)是位运算，只能CPU处理，而且flags一直在被使用，此时CPU自作主张把内存中的flags放入寄存器中，当我们修改flags=1时，只是修改了内存中的flags，没有影响寄存器中的flags，则ctrl c 时执行处理方法，但是寄存器中的flags不会改变，永远不会终止进程。
（3）优化+volatile 情况（有-O2优化，有volatile）
volatile：保持内存的可见性，读取必须从内存中读
此时要求CPU每次使用flags只能从内存中拿flags放入寄存器中，这样修改flags就可以终止进程。
（4）volatile关键字可以保证并发编程中的可见性，有序性。
并发编程中通常会遇到三个问题 原子性问题，可见性问题，有序性问题，java/C/C++中volatile关键字可以保证并发编程中的可见性，有序性。
原子性：一个操作不会被打断，要么一次完成，要么不做。
可见性：一个资源被修改后，是否对其他线程是立即可见的（一个变量的修改存在一个过程，将数据从内存加载的cpu寄存器，进行运算，完毕后交还内存，但是这个过程在代码优化中可能会被编译器优化，将数据放入寄存器，则后续运算只从寄存器取数据，就节省了从内存获取数据的时间）
有序性：简单理解，程序按照写代码的先后顺序执行，就是有序的。（编译器有时候会为了提高程序效率进行代码优化，进行指令重排，来提高效率，而有序性就是禁止指令重排）
而volatile关键字的作用是，防止编译器过度优化，因此具备 可见性与有序性 功能
七.SIGCHLD信号
1.子进程在 终止/暂停（stop）/继续运行时 会给父进程发SIGCHLD信号（ctrl+z是19号信号-暂停进程）
测试：
#include <iostream>
#include <signal.h>
#include <unistd.h>
using namespace std;
void handler(int signo)
{
cout << "子进程退出啦，我确实收到了信号: " << signo << " 我是: " << getpid() << endl;
}
int main()
{
signal(SIGCHLD, handler);
pid_t id = fork();
if (id == 0)
{
while (true)
{
cout << "我是子进程: " << getpid() << endl;
sleep(1);
}
exit(0);
}
// parent
while (true)
{
cout << "我是父进程: " << getpid() << endl;
sleep(1);
}
}（1）进程退出会发信号
（2）进程 暂停（stop）/继续运行 会发信号（ctrl+z是19号信号-暂停进程）
进程暂停也就是进程停止状态，进程停止运行，此时进程无法被kill杀死
2.等待的方案
（1）单个子进程退出
等一个进程waitpid的第一个参数就传-1，可以等待任意进程退出就回收
#include<sys/types.h>
#include<sys/wait.h>
#include<signal.h>
#include<cassert>
#include<unistd.h>
#include<iostream>
using namespace std;
void FreeChld(int signo)
{
assert(signo==SIGCHLD);
pid_t id=waitpid(-1,nullptr,0);
if(id>0)
{
cout<<"父进程等待成功，chld id："<<id<<endl;
}
}
int main()
{
signal(SIGCHLD,FreeChld);
pid_t id=fork();
if(id==0)
{
int cnt=10;
while(cnt--)
{
cout<<"我是子进程，pid："<<getpid()<<"当前cnt："<<cnt--<<endl;
sleep(1);
}
cout<<"子进程退出，进入僵尸状态"<<endl;
exit(0);
}
while(1)
{
cout<<"我是父进程，pid："<<getpid()<<endl;
sleep(1);
}
return 0;
}
（2）多个子进程同时退出时的等待方案
如果10个进程同时退出，在执行方法时会阻塞该信号的多次发出，所以只能捕捉一个信号，导致其他信号丢失，则其他僵尸进程无法捕捉。所以应该给waitpid套一层循环，并加上等待失败的情况。
错误的示例：
这样只等待了一个子进程退出，其他9个全僵尸泄露了
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <cassert>
#include <unistd.h>
#include <iostream>
using namespace std;
void FreeChld(int signo)
{
assert(signo == SIGCHLD);
pid_t id = waitpid(-1, nullptr, 0);
if (id > 0)
{
cout << "父进程等待成功，chld id：" << id << endl;
}
}
int main()
{
signal(SIGCHLD, FreeChld);
for (int i = 0; i < 10; i++)
{
pid_t id = fork();
if (id == 0)
{
int cnt = 10;
while (cnt--)
{
cout << "我是子进程，pid：" << getpid() << "当前cnt：" << cnt-- << endl;
sleep(1);
}
cout << "子进程退出，进入僵尸状态" << endl;
exit(0);
}
}
while (1)
{
cout << "我是父进程，pid：" << getpid() << endl;
sleep(1);
}
return 0;
}
处理后的示例：用给waitpid套一层循环即可等待所有子进程退出。
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <cassert>
#include <unistd.h>
#include <iostream>
using namespace std;
void FreeChld(int signo)
{
assert(signo == SIGCHLD);
while (true)
{
pid_t id = waitpid(-1, nullptr, 0);
if (id > 0)
{
cout << "父进程等待成功，chld id：" << id << endl;
}
else
{
cout<<"所有子进程已退出"<<endl;
break;
}
}
}
int main()
{
signal(SIGCHLD, FreeChld);
for (int i = 0; i < 10; i++)
{
pid_t id = fork();
if (id == 0)
{
int cnt = 5;
while (cnt)
{
cout << "我是子进程，pid：" << getpid() << "当前cnt：" << cnt-- << endl;
sleep(1);
}
cout << "子进程退出，进入僵尸状态" << endl;
exit(0);
}
}
while (1)
{
cout << "我是父进程，pid：" << getpid() << endl;
sleep(1);
}
return 0;
}
（3）多个子进程不同时退出时的等待方案
子进程退出会给父进程发送SIGCILD，这里10个进程7个子进程5秒后退出，后3个子进程10秒再退出。
若是waitpid(-1,nullptr,0)：此时是父进程阻塞等待，那么当前7个子进程退出后，父进程等待成功前7个子进程，此时父进程已经陷入了FreeChld中的循环中了，所以会继续等待，但是后3个仍会运行5秒再退出，这5秒内，父进程会一直阻塞等待，知道这3个子进程退出才会执行waitpid等待成功，这个期间，父进程什么也干不了，一直阻塞着。
若是waitpid(-1,nullptr,WNOHANG)：此时是父进程非阻塞等待，那么当前7个子进程退出后，父进程等待成功前7个子进程，此时父进程进入FreeChld中的循环中，所以会继续等待，后3个仍会运行5秒再退出，这三个进程运行期间，父进程是非阻塞等待会通过id==0（等待成功，但子进程没有退出 ）这个条件跳出循环去做父进程的事情，直到这3个子进程退出又会发出信号，父进程就会回收这3个子进程。这个期间，父进程可以执行自己的代码，并不阻塞，效率高。
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <cassert>
#include <unistd.h>
#include <iostream>
using namespace std;
void FreeChld(int signo)
{
assert(signo == SIGCHLD);
while (true)
{
// -1: 等待任意一个子进程
//当这里是 waitpid(-1, nullptr, 0)时是第一种情况
pid_t id = waitpid(-1, nullptr, WNOHANG);
if (id > 0)
{
cout << "父进程等待成功，chld id：" << id << endl;
}
else if (id == 0) //等待成功，但子进程没有退出
{
cout << "还有子进程没有退出，父进程要忙自己的事了" << endl;
break;
}
else
{ // waitpid 已经没有子进程了调用失败，id<0
cout << "所有子进程已退出" << endl;
break;
}
}
}
int main()
{
signal(SIGCHLD, FreeChld);
for (int i = 0; i < 10; i++)
{
pid_t id = fork();
if (id == 0)
{
int cnt = 0;
if (i < 7)
cnt = 5;
else
cnt = 10;
while (cnt)
{
cout << "我是子进程，pid：" << getpid() << "当前cnt：" << cnt-- << endl;
sleep(1);
}
cout << "子进程退出，进入僵尸状态" << endl;
exit(0);
}
}
while (1)
{
cout << "我是父进程，pid：" << getpid() << endl;
sleep(1);
}
return 0;
}
（4）将SIGCHLD的处理动作置为SIG_IGN——自动释放子进程
下面这个代码：父进程调用sigaction将SIGCHLD的处理动作置为SIG_IGN,这样fork出来的子进程在终止时会自动清理掉,不会产生僵尸进程,也不会通知父进程。
signal(SIGCHLD, FreeChld);
子进程退出的时候，默认的信号处理就是忽略，那调用signal/sigaction手动设置SIG_IGN, 意义在哪里呢？
答：SIG_IGN手动设置：操作系统自动设置：让子进程退出不要给父进程发送信号了，并且自动释放，子进程不会僵尸
#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <signal.h>
#include <cassert>
using namespace std;
int main()
{
// signal(SIGCHLD, FreeChld);
// 子进程退出的时候，默认的信号处理就是忽略吗？
// 调用signal/sigaction SIG_IGN, 意义在哪里呢？
// SIG_IGN手动设置，让子进程退出，不要给父进程发送信号了，并且自动释放
signal(SIGCHLD, SIG_IGN);
for (int i = 0; i < 10; i++)
{
pid_t id = fork();
if (id == 0)
{
//子进程
int cnt = 3;
// if (i < 7)
// cnt = 5;
// else
// cnt = 20;
while (cnt)
{
cout << "我是子进程, pid: " << getpid() << " 当前的cnt: " << cnt-- << endl;
sleep(1);
}
cout << "子进程退出，进入僵尸状态" << endl;
exit(0);
}
// sleep(1);
}
while (true)
{
cout << "我是父进程，我正在运行: " << getpid() << endl;
sleep(1);
}
// //父进程,都是要自己主动等待
// if(waitpid(id, nullptr, 0) > 0)
// {
// cout << "父进程等待子进程成功" << endl;
// }
return 0;
}