【操作系统】信号处理与阻塞函数|时序竞态问题

我要成为C++领域大神

于 2024-06-25 18:24:15 发布

阅读量1.2k

点赞数 36

文章标签：操作系统 linux 多进程面试服务器 c语言笔试

本文链接：https://blog.csdn.net/coldreams/article/details/139966083

版权

🔥博客主页：我要成为C++领域大神
🎥系列专栏：【C++核心编程】【计算机网络】【Linux编程】【操作系统】
❤️感谢大家点赞👍收藏⭐评论✍️

本博客致力于知识分享，与更多的人进行学习交流

关于阻塞函数和信号处理冲突

阻塞函数处于等待状态，等待系统通知或事件消息，如果接收到信号，信号处理函数会中断阻塞函数的执行。这可能导致阻塞函数提前返回。

下面是这一现象的demo程序：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <string.h>
#include <sys/fcntl.h>
#include <signal.h>

void sigint(int signo)
{
    printf("捕捉到了SIGINT %d号信号\n",signo);
}

int main()
{
    struct sigaction act,oact;
    act.sa_handler=sigint;
    act.sa_flags=0;
    sigemptyset(&act.sa_mask);
    sigaction(SIGINT,&act,&oact);
    char buffer[1024];
    bzero(buffer,sizeof(buffer));
    int len;
TryAgain:
    while((len=read(STDIN_FILENO,buffer,sizeof(buffer)))>0)
    {
        write(STDOUT_FILENO,buffer,sizeof(buffer));
        bzero(buffer,sizeof(buffer));
    }
    if(len==-1)
    {
        printf("阻塞函数被信号中断，TryAgain。。。\n");
        goto TryAgain;
    }
        return 0;
}

时序竞态

什么是时序竞态？将同一个程序执行两次，正常情况下，前后两次执行得到的结果应该是一样的。但由于系统资源竞争的原因，前后两次执行的结果有可能得到不一样的结果，这个现象就是时序竞态。

pause函数

进程调用pause函数时，会造成进程主动挂起（处于阻塞状态，并主动放弃CPU），并且等待信号将其唤醒。

信号的处理方式有三种：1. 默认；2. 忽略；3. 捕捉。进程收到一个信号后，会先处理响应信号，再唤醒pause函数。于是有下面几种情况：

① 如果信号的默认处理动作是终止进程，则进程将被终止，也就是说一收到信号进程就终止了，pause函数根本就没有机会返回；

② 如果信号的默认处理动作是忽略，则进程将直接忽略该信号，相当于没收到这个信号，进程继续处于挂起状态，pause函数不返回；

③ 如果信号的处理动作是捕捉，则进程调用完信号处理函数之后，pause返回-1，errno设置为EINTR，表示“被信号中断”。

④ pause收到的信号不能被屏蔽，如果被屏蔽，那么pause就不能被唤醒。

因为alarm函数可以在设定的时间之后发送SIGALRM信号，pause函数又可以将进程挂起等待信号，则二者结合可以自己写一个sleep函数

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

void sig_alrm(int signo)
{
    /*空调用，仅负责捕捉，防止信号杀死进程*/
}

unsigned int mysleep(unsigned int sec)
{
    signal(SIGALRM,sig_alrm);
    unsigned int sleptSec=alarm(sec);//设置一个定时器，定时器结束后发送SIGALRM信号
    int retNum=pause();//设置进程主动挂起，等待信号将其唤醒。信号的处理行为是捕捉，调用完捕捉函数后返回-1
    printf("%d\n",retNum);
    return sleptSec;
}

int main()
{

        while(1)
        {
        mysleep(2);
        printf("2s Passed\n");
        }
                return 0;
}

pause的返回值是-1

时序竞态问题分析

SIGALRM默认动作是终止进程，因此我们要将其捕捉，对SIGALRM注册信号处理函数；

调用alarm(1)函数定时1秒钟；

alarm(1)调用结束，定时器开始计时。调用完alarm后立即调用了sleep函数，因为调用了系统函数，所以会发生内核层切换，进程失去CPU，进入就绪态等待CPU。使得当前进程无法获得CPU；

alarm函数采用自然定时法，定时器将一直计时，与进程状态无关。于是，1秒后，闹钟定时时间到，内核向当前进程发送SIGALRM信号。

在sleep函数调用完毕后，返回进程前，会检测一下是否有未处理的信号，检测到了SIGALRM信号并进行捕捉处理。

信号处理完毕后，返回当前主控流程，并调用pause()函数，挂起等待alarm函数发送的SIGALRM信号将自己唤醒；

但实际SIGALRM信号已经处理完毕，pause()函数永远不会等到，于是就永远挂起了。

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

void sig_alrm(int signo)
{
    /*空调用，仅负责捕捉，防止信号杀死进程*/
}

unsigned int mysleep(unsigned int sec)
{
    signal(SIGALRM,sig_alrm);
    unsigned int sleptSec=alarm(sec);//设置一个定时器，定时器结束后发送SIGALRM信号
    sleep(3);//对SIGALRM进行了处理，导致了进程被永远挂起
    pause();//设置进程主动挂起，等待信号将其唤醒。信号的处理行为是捕捉，调用完捕捉函数后返回-1
    return sleptSec;
}

int main()
{

        while(1)
        {
        mysleep(2);
        printf("2s Passed\n");
        }
                return 0;
}

运行结果：由于pause收不到SIGALRM信号，所以被一直挂起了

解决时序竞态问题

在调用sleep函数之前，屏蔽SIGALRM信号，防止sleep对信号进行处理。在sleep调用完成之后，解除对SIGALRM的屏蔽，然后pause()挂起进程等待SIGALRM将其唤醒。

但在解除屏蔽与pause等待挂起信号之间，还是有可能进行其他操作处理SIGALRM，除非将这两个步骤做成一个“原子操作”。Linux系统提供的sigsuspend函数就具备这个功能。所以，在时序要求比较严格的场合下都应该使用sigsuspend函数，而非pause函数。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <string.h>
#include <sys/fcntl.h>
#include <signal.h>

void sig_alarm(int signo)
{
 //null 空调用
}

unsigned int mysleep(unsigned int seconds)
{

 //设置捕捉函数
 struct sigaction act,oldact;
 act.sa_handler=sig_alarm;
 act.sa_flags=0;
 sigemptyset(&act.sa_mask);
 sigaction(SIGALRM,&act,&oldact);


 //设置信号屏蔽
 sigset_t set,oldset;
 sigemptyset(&set);
 sigaddset(&set,SIGALRM);
 sigprocmask(SIG_SETMASK,&set,&oldset);

 alarm(2);
 sleep(3);
 sigsuspend(&act.sa_mask);
}

int main()
{
    while(1)
    {
     mysleep(2);
     printf("two seconds\n");
    }
        return 0;
}

Shell脚本实现进程的外部控制

实现一个Shell脚本来对进程进行外部控制，可以使用信号机制来控制进程的启动、停止和继续运行。Windows常用的任务管理器就是这个机制，利用外部控制的信号来实现进程的挂起、终止、提高优先级等。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <string.h>
#include <sys/fcntl.h>
#include <signal.h>

void sig_stop(int n)//捕捉SIGUSR1信号
{
    printf("进程已被杀死\n");
    exit(0);
}

void sig_count(int n)
{
    printf("进程已被挂起\n");
    pause();
}

void test_sigaction(void)
{
    struct sigaction act,bct,oact;
    act.sa_handler=sig_stop;
    act.sa_flags=0;
    sigemptyset(&act.sa_mask);
    sigaction(SIGUSR1,&act,&oact);

    bct.sa_handler=sig_count;
    bct.sa_flags=0;
    sigemptyset(&bct.sa_mask);
    sigaction(SIGUSR2,&bct,NULL);
}


void output_pid(void)
{
    int fd=open("config.conf",O_RDWR|O_CREAT,0664);
    pid_t pid=getpid();
    char id[10];
    bzero(id,sizeof(id));

    sprintf(id,"%d",pid);
    write(fd,id,strlen(id));
    close(fd);
}
int main()
{
    test_sigaction();//设定捕捉
    output_pid();
    while(1)
    {
        printf("this is test...\n");
        sleep(2);
    }
    return 0;
}

#!/bin/bash

PID=$(cat config.conf)

if [ $1=="stop" ]
then kill -10 $PID #发送SIGUSR1信号
elif [ $1=="cont" ]
then kill -12 $PID #发送SIGUSR2信号
else print "control call faild\n"
fi

运行结果：通过外部脚本成功杀死进程