信号处理程序行为答案

【问题标题】：Signal Handler Behavior信号处理程序行为
【发布时间】：2018-04-25 20:24:40
【问题描述】：

我有一些关于系统调用signal、kill 和信号处理程序的问题。我有这个代码：

int figlio=-1;
int main(int argc,char* argv[])
    int pid1,pid2,dormi,numero;
    float reciproco;
    signal(SIGUSR1,gestore);
    signal(SIGUSR2,gestore);
    numero=atoi(argv[1]);
    printf("Numero %d\n\n",numero);
    fflush(stdout);
    pid1=fork();
    if(pid1>0)  //PADRE
    {
        pid2=fork();
        if(numero%2 == 0)
            kill(pid1,SIGUSR1);
        else
            kill(pid2,SIGUSR2);
        wait(NULL);
        wait(NULL);
    }
    if(pid1 == 0)   //FIGLIO1
    {   
        //sleep(1);
        printf("%d\n",figlio);
        if(figlio == 1)
        {
            numero=numero*numero*numero;
            fflush(stdout);
            printf("Ho eseguito il cubo %d\n",numero);
        }
        else
        {
            pause();
            if(figlio == 1) //Se il gestore di SIGUSR1 è partito
            {
                fflush(stdout);
                printf("Ciao dal figlio 1\n");
            }
        }
        printf("Figlio1 termina\n\n");
        exit(0);
    }
    if(pid2 == 0)   //FIGLIO2
    {
        if(figlio == 2)
        {
            dormi=numero;
            reciproco=(float)numero;
            reciproco=1/reciproco;
            fflush(stdout);
            printf("Ho eseguito il reciproco %f\n",reciproco);
            sleep(dormi);
            fflush(stdout);
            printf("Mando un segnale a mio fratello %d\n",pid1);
            kill(pid1,SIGUSR1);
        }
        else
            printf("Arrivederci e grazie\n");
        printf("Figlio2 termina\n\n");
        exit(0);
    }   
    return 0;
}

void gestore(int signo)
{
    if(signo == SIGUSR1)
        figlio=1;
    else
        figlio=2;
}

1) 我不明白为什么第一个孩子中的第一个 printf，在没有 sleep(1) 之前返回 -1...似乎处理程序是在孩子开始之后执行的。
2）当一个孩子被杀时，在这之后，调度程序在孩子身上工作还是继续在父亲身上？
3) 处理程序是在发送 kill 时执行还是在调度程序在子进程上工作时执行？

【问题讨论】：

标签： c linux signals handler kill

【解决方案1】：

在fork() 之后，父进程和子进程处于竞争状态。不能保证在孩子拨打printf() 之前，父母有机会向孩子拨打kill()。
如果有多个处理器，两个进程可以同时运行。否则，如果子进程当前未运行，Linux 将设置一些内部状态，即在下一次运行时应将信号传递给子进程，如果该进程尚未运行，则将其标记为可运行。
如果子进程当前正在运行，则立即处理信号。否则，它会在孩子下次运行时处理。处理程序作为处理信号的结果运行。

【讨论】：