unix系统编程day05--Linux中时序竞态的讲解

本文深入探讨了进程控制中的竞态条件，详细解释了pause函数的作用及其实现的sleep函数，对比了使用pause和sigsuspend函数处理信号的差异。同时，文章分析了时序竞态问题，并提供了sigsuspend函数的解决方案。此外，还讨论了全局变量异步I/O的处理，可重入函数的特点，以及SIGCHLD信号的捕捉与子进程的回收。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

竞态条件（时序竞态）

个人理解：由于系统中各个进程抢占cpu时间，导致本应该按照时间发生的事情没有发生，造成时间上的混乱。

pause函数

函数原型 int pause(void)；
作用：挂起当前进程，等待信号来唤醒，处理的信号必须捕捉，否则信号默认动作导致进程直接停止。
返回值：
1. 如果信号的处理动作为默认动作，则进程终止，pause函数没机会返回
2. 如果信号的处理动作为忽略操作，则进程处于挂起状态，函数没有机会返回
3. 如果信号被捕捉，那么首先处理捕捉函数，然后返回-1
4. pause函数收到的信号不能被屏蔽，否则进程一直挂起，无法被唤醒
使用pause和alarm实现的sleep函数：

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

using std::cout;
using std::endl;

void fun(int signo) {
    cout << "SIGALRM has catched" << endl;
}

void mysleep(int sec) {
    int ret = alarm(sec);
    if(ret < 0) {
        perror("alarm failed");
        exit(1);
    }
    
    // 标记，下文会用到
    
    ret = pause();
    if(ret == -1 && errno == EINTR) {
        puts("pause success");
    }
}

int main(void) {
    struct sigaction sig;
    sig.sa_handler = fun;
    sigemptyset(&sig.sa_mask);
    sig.sa_flags = 0;

    int ret = sigaction(SIGALRM, &sig, NULL);
    if(ret == -1) {
        perror("sigaction failed");
        exit(1);
    }
    mysleep(3);
    return 0;    
}

时序竞态

前导例

欲睡觉，定闹钟十分钟，十分钟后闹钟叫醒自己
正常：定时，睡觉，十分钟后被叫醒
异常：定时，被叫走劳动二十分钟，然后回来，闹钟已经响过，不能把我唤醒

时序问题分析

我们分析alarm实现的sleep，如果在“标记”处cpu失去时间，当前进程进入等待状态，sec秒过后，然后信号已经发送完毕，但是pause还没有执行，导致进程永久挂起，虽然这种情况比较概率比较低，但是发生一次将会是致命的错误，尤其是在服务器当中

针对解决mysleep的的时序问题

我们考虑，如果在执行pause函数之前我们屏蔽了SIGALRM信号，然后在执行pause函数的同时解除SIGALRM信号的屏蔽，是不是可以让alarm发挥作用，sigsuspend可以做到这一点。

sigsuspend函数

函数原型：int sigsuspend(const sigset_t * mask);
函数作用：主动挂起进程，并且使用mask作为阻塞信号集（信号屏蔽字）
返回值：成功返回-1，并设置errno为EINTR

我们通过sigsuspend实现sleep来避免时序竞态带来的后果，代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <iostream>
using std::cout;
using std::endl;

void callback(int signo) {
    puts("signal has catched");
}

void mysleep(unsigned int sec) {
    sigset_t newset, oldset, susmask;
    int ret = 0;
    sigemptyset(&newset);
    sigaddset(&newset, SIGALRM);
    ret = sigprocmask(SIG_BLOCK, &newset, &oldset);
    if(ret == -1) {
        perror("sigprocmask failed");
        exit(1);
    }

    struct sigaction action, oldaction;
    action.sa_handler = callback;
    sigemptyset(&action.sa_mask);
    action.sa_flags = 0;
    ret = sigaction(SIGALRM, &action, &oldaction);
    if(ret == -1) {
        perror("sigaction failed");
        exit(1);
    }

    ret = alarm(sec);
    susmask = oldset;
    if(sigismember(&susmask, SIGALRM)) {
        sigdelset(&susmask, SIGALRM);
    }
    sigsuspend(&susmask);
    
    ret = sigaction(SIGALRM, &oldaction, &action);
    if(ret == -1) {
        perror("sigaction failed2");
        exit(1);
    }
    ret = alarm(0);
    sigprocmask(SIG_SETMASK, &oldset, &newset);
}

int main() {
    mysleep(1);
    cout << "***" << endl;
    return 0;
}

全局变量异步I/O

我们使用父进程和子进程轮流数数代码：

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

int n;
pid_t pid;

void parent_fun(int signo) {
    printf("I'm parent, my pid = %d, n = %d\n", getpid(), n);
    n += 2;
    kill(pid, SIGUSR1);
    //sleep(1);
}

void son_fun(int signo) {
    printf("I'm son,    my pid = %d, n = %d\n", getpid(), n);
    n += 2;
    kill(getppid(), SIGUSR2);
    //sleep(1);
}

int main(void) {
    if((pid = fork()) == -1) {
        perror("fork error");
        exit(1);
    } else if(pid > 0) {
        n = 1;
        struct sigaction action;
        action.sa_handler = parent_fun;
        sigemptyset(&action.sa_mask);
        action.sa_flags = 0;
        sigaction(SIGUSR2, &action, NULL);
        sleep(1);
        parent_fun(0);
        while(1) {
        }
    } else {
        n = 2;
        struct sigaction action;
        action.sa_handler = son_fun;
        sigemptyset(&action.sa_mask);
        action.sa_flags = 0;
        sigaction(SIGUSR1, &action, NULL);
        while(1) {
        }
    }
    return 0;
}

可重入/不可重入函数

可重入函数和不可重入的区别，可重入函数不存在全局和static数据结构，malloc/free，也不能使用标准IO。

捕捉SIGCHLD信号

什么时候会产生SIGCHLD信号：
1. 子进程终止死亡。
2. 子进程接收到SIGSTOP信号，进入暂停状态
3. 子进程接收到SIGCONT信号，进入继续执行状态

使用SIGCHLD回收子进程

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

void do_wait(int signo) {
    pid_t pid = 0;
    int status;
    //注意下面是while
    while((pid = waitpid(0, &status, WNOHANG)) > 0) {
        if(WIFEXITED(status)) {
            printf("child %d exit with %d\n", pid, WEXITSTATUS(status));
        } else if(WIFSIGNALED(status)) {
            printf("child %d signal by %d\n", pid, WTERMSIG(status));
        }
    }
}

int main(int argc, char ** argv) {
    pid_t pid;
    int i = 0;
    printf("%d %s\n", argc, argv[0]);
    sleep(1);
    for(i = 0; i < 10; i++) {
        if((pid = fork()) == 0) {
            break;
        } else if(pid == -1) {
            perror("fork failed");
            exit(1);
        }
    }
    if(pid == 0) {
        printf("child id = %d\n", getpid());
        sleep(1);
        return i + 1;
    } else if(pid > 0) {
        struct sigaction action;
        action.sa_handler = do_wait;
        action.sa_flags = 0;
        sigemptyset(&action.sa_mask);
        sigaction(SIGCHLD, &action, NULL);
        while(1) {
            printf("parent id = %d\n", getpid());
            sleep(1);
        }
    }
    return 0;
}