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


int quit = 0;

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

int main()
{
    signal(2,handler);
    //注意这里我们故意没有携带while的代码块，故意让编译器认为在main中，quit只会被检测
    while (!quit);
    printf("main quit  正常\n");
    return 0;
}

上面这段代码的意思是：首先我们将2号信号捕捉让其执行我们自己的handler方法，然后我们有一个全局变量quit，进入自定义方法后先打印quit即将由0变成1，然后将quit变成1，然后进入main函数中，while循环中是quit的逻辑反，本来循环中quit为真就一直在循环中，取反后变成了只要quit为假也就是0就会一直在死循环，正常情况下不会进入循环直接打印main quit ，下面我们看一下gcc的优化级别：

 我们可以看到有O0,O1,O2,O3这几个优化级别，我们直接用O2这个级别演示一下，只需要在gcc后面加上级别即可：

 运行后我们可以发现程序一直在死循环中，下面我们不用gcc的优化试一下：

 我们可以看到当编译器对我们的代码没有优化的时候反而我们的代码可以正常运行，也就是说编译器的优化并不都是往好的方式优化，下面我们解释一下原理：

 如上图所示：代码是存储在内存中的，而while判断也是一段代码，这段代码也是会被CPU所执行的，而在while循环内部有quit的判断，这个时候会将quit这段代码加载到CPU的寄存器当中，根据寄存器中quit的大小来在while循环中做判断，（具体CPU如何知道执行到哪一句代码是因为CPU中会有一个PC指针，这个指针指向下一段代码的位置）。而正常的情况如下图：

 当我们的信号捕捉的自定义方法将quit改为1时，内存中的quit就变成1了，CPU读取代码将quit=1这段代码加载到寄存器当中然后判断while，这个时候不满足while循环的条件打印一句话并退出即可。但是经过编译器的优化后就变成了一下这样：

由于while是一个循环，每次都会将quit的数据加载到寄存器中判断while是否满足条件，当编译器发现while这个循环内部没有任何更改quit判断语句的代码块，这个时候编译器就会觉得不用每次都将quit加载到寄存器中做判断，所以优化后就变成了：第一次将quit=0加载到寄存器判断while语句后，以后就不再从内存加载quit的数据到寄存器中了，而是直接用第一次加载到寄存器中的quit值来判断while，所以这就是while一直死循环的原因，因为quit在while中判断的时候一直为假！

 那么为了不让编译器给我们的代码优化，我们就要告诉编译器保证每次检测都要尝试着从内存中进行数据读取，不要用寄存器中的数据，让内存数据不可见。

下面我们演示一下：

 这个时候我们的程序就不会被优化，从而可以按照我们的预期来运行了。在这里我们要说明一下，我们理解编译器的优化实际上是：1.编译器优化的本质是在代码上动手脚。2.CPU其实很笨，用户喂给它什么代码它才执行什么代码。

volatile 的作用：保持内存的可见性，告知编译器，被该关键字修饰的变量，不允许被优化，对该变量的任何操作，都必须在真实的内存中进行操作。

3.SIGCHLD信号

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
void handler(int signo)
{
    printf("捕捉到一个信号:%d,who: %d\n",signo,getpid());
}
int main()
{
    signal(SIGCHLD,handler);
    pid_t id = fork();
    if (id==0)
    {
        //child
        int cnt = 5;
        while (cnt)
        {
            printf("我是子进程，我的pid:%d,ppid:%d\n",getpid(),getppid());
            sleep(1);
            cnt--;
        }
        exit(1);
    }
    //父进程
    while (1)
    {
        sleep(1);
    }
    return 0;
}

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
pid_t id;
void handler(int signo)
{
    printf("捕捉到一个信号:%d,who: %d\n",signo,getpid());
    sleep(5);
    pid_t res = waitpid(-1,NULL,0);
    if (res>0)
    {
        printf("wait success,res:%d,id:%d\n",res,id);
    }
}
int main()
{
    signal(SIGCHLD,handler);
    id = fork();
    if (id==0)
    {
        //child
        int cnt = 5;
        while (cnt)
        {
            printf("我是子进程，我的pid:%d,ppid:%d\n",getpid(),getppid());
            sleep(1);
            cnt--;
        }
        exit(1);
    }
    //父进程
    while (1)
    {
        sleep(1);
    }
    return 0;
}

 通过以上代码我们可以看到最后成功等待了子进程。也就是说我们现在这样的方法比我们之前让父进程什么也不干只等待子进程退出的效率高多了。

注意：以上代码的要求，如果你的父进程没有事干，那么还是用以前的方法也就是阻塞式等待，因为父进程闲着也是闲着。

如果你的父进程很忙，而且不退出，就可以用上述我们信号的方法。

当然我们以上的代码实际上不完全对，因为遇到多个子进程退出的时候是有问题的，下面我们用代码写出这个问题：

 现在我们会有10个子进程，但是我们之前说过，pending只有一个符号位记录17号信号，第一个子进程退出后pending位变成1，下一次来了还是变成1，那么这就出问题了，因为当父进程忽略子进程的退出信号的时候pending位还是1，这个时候下一个子进程再发信号将pending的位又置为1那么前面那个忽略的信号就丢失了，我们后面想回收之前忽略的信号也没法回收，所以代码的现象是10个进程只能回收几个子进程。

 运行起来后我们发现10个进程才回收了2个子进程，要解决这个情况很简单，只需要让父进程死循环的等待回收所有子进程即可：

 通过运行结果我们可以看到确实将所有的子进程都成功回收了，那么如果我们有10个子进程，但是只有10个子进程需要退出，这样的情况该怎么办呢？我们只需要将等待方式设为非阻塞式等待，也就是WNOHANG