C语言:高级并发操作(信号)

引言

同步和异步的使用。

异步事件处理的两种方法:查询法、通知法。(单核机器不存在异步)

一、信号

1. 信号的概念

信号是软件中断。信号的响应依赖于中断。中断是底层硬件的机制。

2. signal函数

kill -l命令查看所有的信号。1 -31 属于标准信号 34 - 64属于实时信号

typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

展示形式为: void (* signal(int signum, void (*func)(int) ) ) (int )

信号会打断阻塞的系统调用。

cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void mySig()
{

    write(1,".",1);
}

int main()
{

    signal(SIGINT,SIG_IGN);//运行过程中忽略这个信号
    signal(SIGINT,mySig);
    
    int i;
    for(i = 0;i<10;i++)
    {
        write(1,"*",1);
        sleep(1);
    }
    return 0;
}

重构之前的mycpy.c 对于open write read 函数增加出现系统调用打断的行为判断

mycpy.c

cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <error.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

#define BUF_SIZE    1024*100
int main(int argc,char **argv)
{

    int fps,fpd;
    int ret;
    char buf[BUF_SIZE];
    int len,pos;
    if(argc <3)
    {
        fprintf(stderr,"Usage:%s <src_file> <dest_file>\n",argv[0]);
        exit(1);
    }
    do
    {
        fps = open(argv[1],O_RDONLY);
        if(fps <0)
        {
            if(errno != EINTR)
            {
                perror("open");
                exit(1);
            }
        }
    }while(fps<0);
    do
    {
        fpd = open(argv[2],O_WRONLY|O_CREAT|O_TRUNC,0600 );
        if(fpd <0)
        {
            if(errno != EINTR)
            {
                close(fps);
                perror("open");
                exit(1);
            }
        }
    }while(fpd<0);
    while(1)
    {
        len = read(fps,buf,BUF_SIZE);
        if(len < 0)
        {
            if(errno == EINTR)
                continue;
            perror("read()");
            break;
        }
        if(len ==0)
            break;

        pos = 0;
        while(len > 0)
        {
            ret = write(fpd,buf+pos,len);
            if(ret <0)
            {
                if(errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            pos += ret;
            len-=ret;
        }
    
    }

    close(fpd);
    close(fps);

    return 0;
}

3. 信号的不可靠

标准的信号会丢失,实时信号不会丢失。指的是信号的行为不可靠。(第一次调用还未结束,第二次调用就开始了)

4. 可重入函数

第一次调用还未结束,第二次调用不会出错叫可重入函数(reentrant)。所有的系统调用都是可重入的,一部分库函数也是可重入的,比如说:memcpy rand_r localtime_r memove

5. 信号的响应过程

mask(信号屏蔽字,32位一般情况都是1)pending(32位 位图,初始都为0),收到信号后pending位置1,内核在kernal态进入到user态时,会用mask值 & pending 获取发生的信号,将mask与pending全部置为0,执行函数,执行完毕将mask位置1。

信号从收到到响应有一个不可避免的延迟。

思考:

如何忽略掉一个信号? 将mask位置0

标准信号为什么会丢失? 在执行信号时,pending位置多次1,此时mask位是0

标准信号的响应没有严格的顺序。

不能从信号处理函数中随意的往外跳。(sigsetjmp,siglongjmp)

6. 相关常用函数

kill

发送一个信号到一个进程或进程组

raise

给当前进程或者线程发送一个信号

alarm

指定秒数,发送SIGALRM信号。默认alarm会杀掉当前程序。alarm不能实现多任务的计时器,只能执行最后一次设置的计时器。

alarm.c
cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void mySig()
{

    write(1,".",1);
}

int main()
{
    alarm(5);
    alarm(2);
    alarm(10);
    while(1)
        pause();
#if 0
   signal(SIGALRM,mySig);
    
    int i;
    for(i = 0;i<10;i++)
    {
        write(1,"*",1);
        alarm(1);
        sleep(1);
    }
#endif 
    return 0;
}

5秒进行计数,不用alarm实现

5sec.c
cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <time.h>


int main()
{
    time_t end;
    long long  count = 0;
   end = time(NULL)+5;
    while(time(NULL)<= end)
    {
        count++;
    }
    printf("count = %lld \n",count);
    return 0;
}

使用alarm实现

5sec_signal.c
cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <time.h>

static int loop = 1;

void alrm_handler(int num)
{
    loop = 0;
}

int main()
{

    signal(SIGALRM,alrm_handler);
    alarm(5);

    long long  count=0;
    while(loop)
    {
        count++;
    }
    printf("count = %lld \n",count);
    return 0;
}

gcc -S 5sec_signal.c 会产生 5sec_singal.s的汇编文件

使用-O1优化之后,程序会一直执行下去,因为程序中while中没有用到loop,优化后loop的值会直接从寄存器取程序while会一直成立,volatile关键字告诉程序要去真正的地址取数据,不要从内存获取

cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <time.h>

static volatile int loop = 1;  //从真实的空间去取数据

void alrm_handler(int num)
{
    loop = 0;
}

int main()
{

    signal(SIGALRM,alrm_handler);
    alarm(5);

    long long  count=0;
    while(loop)
    {
        count++;
    }
    printf("count = %lld \n",count);
    return 0;
}
mycat.c
cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <error.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

#define BUF_SIZE    1024*100
int main(int argc,char **argv)
{

    int fps,fpd=1;
    int ret;
    char buf[BUF_SIZE];
    int len,pos;
    if(argc <2)
    {
        fprintf(stderr,"Usage:%s <src_file> <dest_file>\n",argv[0]);
        exit(1);
    }
    do
    {
        fps = open(argv[1],O_RDONLY);
        if(fps <0)
        {
            if(errno != EINTR)
            {
                perror("open");
                exit(1);
            }
        }
    }while(fps<0);
    
    while(1)
    {
        len = read(fps,buf,BUF_SIZE);
        if(len < 0)
        {
            if(errno == EINTR)
                continue;
            perror("read()");
            break;
        }
        if(len ==0)
            break;

        pos = 0;
        while(len > 0)
        {
            ret = write(fpd,buf+pos,len);
            if(ret <0)
            {
                if(errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            pos += ret;
            len-=ret;
        }
    
    }

    close(fps);

    return 0;
}

实例:使用单一计时器,构造一组函数实现,任意数量的计时器。

pause

等待一个信号来打断他,让程序不在忙等(while函数)

abort

给当前进程发送一个SIGABRT信号,并且产生一个core文件

system

调用shell完成shell命令。 execl("/bin/sh", "sh", "-c", command, (char *) NULL);

如果在信号中使用,需要block 这个SIGCHLD 信号,并且 忽略SIGINT SIGQUIT信号。

sleep

某些平台 用alarm+pause封装 ,当前平台用nanolseep封装,考虑到移植最好不要使用sleep.可以使用usleep,select

7. 信号集

int sigemptyset(sigset_t *set);

int sigfillset(sigset_t *set);

int sigaddset(sigset_t *set, int signum);

int sigdelset(sigset_t *set, int signum);

int sigismember(const sigset_t *set, int signum);

8. 信号屏蔽字mask/pending集处理

/* Prototype for the glibc wrapper function

glibc包装器函数的原型

*/

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

/* Prototype for the underlying system call

底层系统调用的原型

*/

int rt_sigprocmask(int how, const kernel_sigset_t *set,

kernel_sigset_t *oldset, size_t sigsetsize);

/* Prototype for the legacy system call (deprecated)

旧系统调用的原型(已弃用)

*/

int sigprocmask(int how, const old_kernel_sigset_t *set,

old_kernel_sigset_t *oldset);

cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void mySig()
{

    write(1,".",1);
}

int main()
{

    signal(SIGINT,mySig);
    
    int i;
    sigset_t set,old_set;
    sigemptyset(&set);
    sigaddset(&set,SIGINT);
    for(i = 0;i<1000;i++)
    {

        sigprocmask(SIG_BLOCK,&set,NULL); //堵塞 SIGINT信号
        for(int j=0;j<5;j++)
        {
        write(1,"*",1);
        sleep(1);  // 信号可以打断堵塞 的系统调用
        }
        write(1,"\n",1);
        sigprocmask(SIG_UNBLOCK,&set,NULL); //解除堵塞信号

    }
    return 0;
}
cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void mySig()
{

    write(1,".",1);
}

int main()
{

    signal(SIGINT,mySig);
    
    int i;
    sigset_t set,old_set;
    sigemptyset(&set);
    sigaddset(&set,SIGINT);
    for(i = 0;i<1000;i++)
    {

        sigprocmask(SIG_BLOCK,&set,&old_set); // 保存之前的状态
        for(int j=0;j<5;j++)
        {
        write(1,"*",1);
        sleep(1);  // 信号可以打断堵塞 的系统调用
        }
        write(1,"\n",1);
        sigprocmask(SIG_SETMASK,&old_set,NULL); //回复当前的状态

    }
    return 0;
}
cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void mySig()
{

    write(1,".",1);
}

int main()
{

    signal(SIGINT,mySig);
    
    int i;
    sigset_t set,old_set,save_set;
    sigemptyset(&set);
    sigaddset(&set,SIGINT);
    sigprocmask(SIG_UNBLOCK,&set,&save_set);// 模块话编程,先保存之前的状态。


    for(i = 0;i<1000;i++)
    {

        sigprocmask(SIG_BLOCK,&set,NULL);
        for(int j=0;j<5;j++)
        {
        write(1,"*",1);
        sleep(1);  // 信号可以打断堵塞 的系统调用
        }
        write(1,"\n",1);
        sigprocmask(SIG_UNBLOCK,&old_set,NULL); 

    }
    sigprocmask(SIG_SETMASK,&save_set,NULL); //结束后,恢复之前保存的状态。
    return 0;
}

9. 扩展

sigsuspend()

实现信号驱动程序。

susp.c
cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void mySig()
{

    write(1,".",1);
}

int main()
{

    signal(SIGINT,mySig);
    
    int i;
    sigset_t set,old_set,save_set;
    sigemptyset(&set);
    sigaddset(&set,SIGINT);
    sigprocmask(SIG_UNBLOCK,&set,&save_set);// 模块话编程,先保存之前的状态。

    sigprocmask(SIG_BLOCK,&set,&old_set);

    for(i = 0;i<1000;i++)
    {

   //     sigprocmask(SIG_BLOCK,&set,&old_set);
        for(int j=0;j<5;j++)
        {
        write(1,"*",1);
        sleep(1);  // 信号可以打断堵塞 的系统调用
        }
        write(1,"\n",1);
        sigsuspend(&old_set);
/* sigsuspend的原子操作
        sigset_t tmpset;
        sigprocmask(SIG_SETMASK,&old_set,&tmpset); //解除阻塞 
        pause(); //响应信号
        sigprocmask(SIG_SETMASK,&tmpset,NULL); //重新恢复信号。

*/
    }
    sigprocmask(SIG_SETMASK,&save_set,NULL); //结束后,恢复之前保存的状态。
    return 0;
}

sigaction()

用于替换signal,signal有使用上的缺陷。

int sigaction(int signum, const struct sigaction *act,

struct sigaction *oldact);

struct sigaction {

void (*sa_handler)(int);

void (*sa_sigaction)(int, siginfo_t *, void *);

sigset_t sa_mask;

int sa_flags;

void (*sa_restorer)(void);

};

第三个参数来源于:

#include <ucontext.h>

int getcontext(ucontext_t *ucp);

int setcontext(const ucontext_t *ucp);

struct sigaction sa;

sa.sa_handler = daemon_exit; //指定要执行的函数

sigemptyset(&sa.sa_mask);

sigaddset(&sa.sa_mask,SIGINT)

sigaddset(&sa.sa_mask,SIGQUIT)

sigaddset(&sa.sa_mask,SIGTERM)

sa.sa_flag = 0;

sigaction(SIGINT,&sa,NULL);

while true ;do kill -ALRM 121812;done;SHELL脚本

重新更新mytbf,不响应终端的信号。

mytbf.c
cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <error.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <sys/time.h>
#include "mytbf.h"

struct mytbf_st
{
    int cps;
    int burst;
    int token;
    int pos;

};
static struct mytbf_st* job[MYTBF_MAX];
static int inited = 0;

typedef void (*sighandler_t)(int);

struct sigaction alrm_sa_save;

static int get_free_pos(void)
{
    for(int i=0;i< MYTBF_MAX;i++)
    {
        if(job[i]==NULL)
            return i;
    }
    return -1;
}

static void alrm_action(int num,siginfo_t*infop,void *unsed)
{
    if(!infop->si_code == SI_KERNEL) //响应kernal来的信号,一般从程序中发出就是kernal来的。
        return;
    for(int i=0;i<MYTBF_MAX;i++)
    {
        if(job[i] != NULL)
        {
            job[i]->token += job[i]->cps;
            if(job[i]->token >job[i]->burst )
            {
                job[i]->token = job[i]->burst;
            }
        }
    }

}

static void module_unload()
{
    sigaction(SIGALRM,&alrm_sa_save,NULL);
    
    struct itimerval itv;
    itv.it_interval.tv_sec = 0;
    itv.it_interval.tv_usec = 0;
    itv.it_value.tv_sec = 0;
    itv.it_value.tv_usec = 0;
    setitimer(ITIMER_REAL,&itv,NULL);

    for(int i=0;i<MYTBF_MAX;i++)
        free(job[i]);
}

static void module_load()
{
    struct sigaction sa;
    
    sa.sa_sigaction  = alrm_action; 
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_SIGINFO; //表示传入的是三参的形式
    sigaction(SIGALRM,&sa,&alrm_sa_save);
    
    struct itimerval itv;
    itv.it_interval.tv_sec = 1;
    itv.it_interval.tv_usec = 0;
    itv.it_value.tv_sec = 1;
    itv.it_value.tv_usec = 0;

    
    setitimer(ITIMER_REAL,&itv,NULL);

    atexit(module_unload);
}

mytbf_t* mytbf_init(int cps ,int burst)  //C语言中,void*可以赋值给任何类型的指针,任何类型的指针也都可以赋值给void*
{
    struct mytbf_st*me;
    int pos;
    if(inited == 0)
    {
        module_load();
        inited = 1;
    }

    pos = get_free_pos();
    if(pos < 0)
        return NULL;

    me = malloc(sizeof(*me));
    if(me == NULL)
        return NULL;

    me->cps = cps;
    me->burst = burst;
    me->token = 0;
    me->pos = pos;
    job[pos] = me;

    return me;

}
static int min(int token,int size)
{
	if(token> size)
		return size;
	return token;
}
int mytbf_fetchtoken(mytbf_t*ptr,int size)  //获取token
{
    if(size <= 0)
        return -EINVAL;  //参数非法
    struct mytbf_st*me = ptr;
    while(me->token <= 0 )  //token为空就等待
        pause();
    
   //  int n = min(me->token,size);
    int n = (me->token>size?size:me->token);
    me->token -= n;
    return n;
}

int mytbf_returntoken(mytbf_t*ptr,int size)  //返还token
{
    if(size<=0)
        return -EINVAL;
    struct mytbf_st*me = ptr;

    me->token+= size;
    if(me->token > me->burst)
        me->token  = me->burst;
    return size;
}

int mytbf_destroy(mytbf_t*ptr)
{
    struct mytbf_st *me;
    me = ptr;
    job[me->pos] = NULL;
    free(ptr);
    return 0;
    
}

setitimer()

#include <sys/time.h>

int getitimer(int which, struct itimerval *curr_value);

int setitimer(int which, const struct itimerval *new_value,

struct itimerval *old_value)

比alarm时间更加的准确

struct itimerval {

struct timeval it_interval; /* Interval for periodic timer */

struct timeval it_value; /* Time until next expiration */

};

struct timeval {

time_t tv_sec; /* seconds */

suseconds_t tv_usec; /* microseconds */

};

slowcat.c
cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <error.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>


#define CPS 100
#define BUF_SIZE    CPS

static volatile int loop = 0;

static void alrm_handler(int num)
{
//     alarm(1);
    loop = 1;
}

int main(int argc,char **argv)
{

    int fps,fpd=1;
    int ret;
    char buf[BUF_SIZE];
    int len,pos;
    if(argc <2)
    {
        fprintf(stderr,"Usage:%s \n",argv[0]);
        exit(1);
    }
    signal(SIGALRM,alrm_handler);
//    alarm(1);
    struct itimerval itv;
    itv.it_interval.tv_sec = 1;
    itv.it_interval.tv_usec = 0;
    itv.it_value.tv_sec = 1;
    itv.it_value.tv_usec = 1;

    if(setitimer(ITIMER_REAL,&itv,NULL) <0)
    {
        fprintf(stderr,"setitimer:%s",strerror(errno));
    }

    do
    {
        fps = open(argv[1],O_RDONLY);
        if(fps <0)
        {
            if(errno != EINTR)
            {
                perror("open");
                exit(1);
            }
        }
    }while(fps<0);
    
    while(1)
    {
        //while(!loop);
        while(loop == 0)
            pause();   //用于等待一个打断的到来。不加则是忙等。

        loop = 0;
        while(1)
        {
        len = read(fps,buf,BUF_SIZE);
        if(len < 0)
        {
            if(errno == EINTR)
                continue;
            perror("read()");
            break;
        }
        break;
        }
        if(len ==0)
            break;

        pos = 0;
        while(len > 0)
        {
            ret = write(fpd,buf+pos,len);
            if(ret <0)
            {
                if(errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            pos += ret;
            len-=ret;
        }
    
    }

    close(fps);

    return 0;
}

int sigpending(sigset_t *set); 不清楚使用场景。

10. 实时信号

标准信号会丢失,实时信号不会丢失,需要排队,响应有一个顺序。

SIGUSR1 SIGUSR2是预留的信号。

susp_rt.c

cpp 复制代码
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

#define MYRTSIG (SIGRTMIN+6)


void mySig()
{

    write(1,".",1);
}

int main()
{

    signal(MYRTSIG,mySig);
    
    int i;
    sigset_t set,old_set,save_set;
    sigemptyset(&set);

    sigaddset(&set,MYRTSIG);

    sigprocmask(SIG_UNBLOCK,&set,&save_set);// 模块话编程,先保存之前的状态。

    sigprocmask(SIG_BLOCK,&set,&old_set);

    for(i = 0;i<1000;i++)
    {

   //     sigprocmask(SIG_BLOCK,&set,&old_set);
        for(int j=0;j<5;j++)
        {
        write(1,"*",1);
        sleep(1);  // 信号可以打断堵塞 的系统调用
        }
        write(1,"\n",1);
        sigsuspend(&old_set);
    }
    sigprocmask(SIG_SETMASK,&save_set,NULL); //结束后,恢复之前保存的状态。
    return 0;
}

kill -40 pid 杀掉信号,可以使程序继续运行,切发送多次信号都会执行。排队次数用ulimit -i查看。

相关推荐
Envyᥫᩣ12 分钟前
C#语言:从入门到精通
开发语言·c#
童先生33 分钟前
Go 项目中实现类似 Java Shiro 的权限控制中间件?
开发语言·go
lulu_gh_yu34 分钟前
数据结构之排序补充
c语言·开发语言·数据结构·c++·学习·算法·排序算法
Re.不晚1 小时前
Java入门15——抽象类
java·开发语言·学习·算法·intellij-idea
老秦包你会1 小时前
Qt第三课 ----------容器类控件
开发语言·qt
凤枭香1 小时前
Python OpenCV 傅里叶变换
开发语言·图像处理·python·opencv
ULTRA??1 小时前
C加加中的结构化绑定(解包,折叠展开)
开发语言·c++
远望清一色1 小时前
基于MATLAB的实现垃圾分类Matlab源码
开发语言·matlab
confiself2 小时前
大模型系列——LLAMA-O1 复刻代码解读
java·开发语言
XiaoLeisj2 小时前
【JavaEE初阶 — 多线程】Thread类的方法&线程生命周期
java·开发语言·java-ee