LinuxC应用开发学习笔记（十一）—并发（信号）

最新推荐文章于 2023-05-28 18:23:16 发布
最新推荐文章于 2023-05-28 18:23:16 发布
阅读量533 收藏 5
点赞数
分类专栏： Linux操作系统 C语言 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46152793/article/details/122294359
版权
这篇博客深入探讨了信号处理的概念，包括同步与异步信号、信号的不可靠性以及可重入函数。文章通过实例展示了如何使用signal()、kill()、alarm()和setitimer()等函数来处理和响应信号，并讨论了信号集合的使用。此外，还介绍了守护进程的创建和实时信号的应用，以及如何在多线程环境中处理信号。最后，提到了信号驱动程序和实时信号的例子，强调了在高并发和实时性场景下的信号管理策略。
摘要由CSDN通过智能技术生成

信号

同步
异步：什么时候到来不知道，产生什么结果不知道
处理:查询法、通知法

一、信号（初步异步、强烈异步）

1、信号的概念

信号是软件中断。
信号的响应依赖于中断。

2、signal();

void signal(int signum,void (*func)(int )))(int);
信号会打断阻塞的系统调用。如：open 和 read

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

void int_handler(int s)
{
    write(1,"!",1);
}

int main()
{
    int i;

    /*把打断信号忽略掉*/
    //signal(SIGINT,SIG_IGN);

    signal(SIGINT,int_handler);
    

    for (i = 0; i < 10; i++)
    {
        write(1,"*",1);
        sleep(1);
    }
    exit(0);
}

3、信号的不可靠

信号的行为不可靠，因为执行现场不可控。

4、可重入函数

所有的系统调用都是可重入的，一部分库函数也是可重入的，比如说：memcpy， localtime。函数有_r版本，原来的版本就不能用在信号处理中。

5、信号的响应过程

1）信号从收到到响应有一个不可避免的延迟。
思考：1、如何忽略掉一个信号的？？？
把指定信号的mask位置为0,阻止信号被响应。但是不能阻止信号到来。
2、标准信号为什么要丢失？？？
位图，来1W次还是置为1次1,不会累加，不会计数。
3、标准信号的响应没有严格的顺序。

每个进程都有这样的两个位图，当有一个信号发出的时候，pending会置1，然后mask&pending，从kernel态到user态有一个时延。
信号时从kernel到user的路上响应。
多线程再解释：mask置为0，是防止重入现象。

在这里插入图片描述

6、相关的常用函数

kill();
kill是用来给进程发出信号，
raise();
alarm();
里程碑式函数。有一个稍微准确点的时间。
setitimer();//精度控制更好，没有延迟累计的。

例：使用单一计时器构造一组函数，实现任意数量的计时器

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

int main()
{
    /*无法实现多任务的计数器，会调用最后一个alarm*/
    alarm(10);
    alarm(5);
    alarm(1);
    while (1)
        pause();
    
    exit(0);
}

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

int main()
{
    time_t end;
    long long count = 0;
    end = time(NULL) + 5;

    while (time(NULL) <= end)
    {
        count++;
    }
    printf("%lld\n",count);    
    exit(0);
}

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

//易变符
static volatile int loop = 1;

static void alarm_handler(int s)
{
    loop = 0;
}

int main()
{
    long long count = 0;

    //触发信号，需要放在alarm之前
    signal(SIGALRM,alarm_handler);

    alarm(5);

    while (loop)
        count++;
    
    printf("%lld\n",count);

    
    exit(0);
}
漏桶实现
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define BUFSIZE 1024


int main(int argc,char **argv)
{
    int sfd,dfd = 1;
    int ch,len,ret,pos = 0;
    char buf[BUFSIZE];


    if (argc < 2)
    {
        fprintf(stderr,"Usage : %s <source_filename> <dest_filename>\n",argv[0]);
        exit(1);
    }
    
    do
    {
        sfd = open(argv[1],O_RDONLY);
        if (sfd < 0)
        {
            if(errno != EINTR)
            {
                perror("open()");
                exit(1);
            }
        }
    } while (sfd < 0);
    

    while (1)
    {
        /*len read 10 byte*/
       len = read(sfd,buf,BUFSIZE);
        if (len<0)
        {
            if (errno == EINTR)
                continue;
            perror("read()");
            break;
        }
        if (len == 0)
        {
            break;
        }

        pos = 0;

        /*判断len是否全部填入*/
        while (len > 0)
        {
            /*from buf read len byte to dfd*/
            ret = write(dfd,buf+pos,len);
            if (ret < 0 )
            {
                if (errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            /*计算下一个写入的位置*/
            pos += ret;
            /*计算剩下的没填入的字节数*/
            len -= ret;
        }
     
    }

    close(sfd);
    

    exit(0);
}

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

#define CPS     10
#define BUFSIZE CPS

static volatile int loop = 0;

static  void alarm_handler(int s)
{
    alarm(1);
    loop = 1;
}

int main(int argc,char **argv)
{
    int sfd,dfd = 1;
    int ch,len,ret,pos = 0;
    char buf[BUFSIZE];

    if (argc < 2)
    {
        fprintf(stderr,"Usage : %s <source_filename> <dest_filename>\n",argv[0]);
        exit(1);
    }
     
    signal(SIGALRM,alarm_handler);
    alarm(1);

    do
    {
        sfd = open(argv[1],O_RDONLY);
        if (sfd < 0)
        {
            if(errno != EINTR)
            {
                perror("open()");
                exit(1);
            }
        }
    } while (sfd < 0);
    

    while (1)
    {

        while(!loop)
            ;
        loop = 0;

        /*len read 10 byte*/
        while(len = read(sfd,buf,BUFSIZE)<0)
        {
            if (errno == EINTR)
                continue;
            perror("read()");
            break;
        }
        if (len == 0)
            break;

        pos = 0;

        /*判断len是否全部填入*/
        while (len > 0)
        {
            /*from buf read len byte to dfd*/
            ret = write(dfd,buf+pos,len);
            if (ret < 0 )
            {
                if (errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            /*计算下一个写入的位置*/
            pos += ret;
            /*计算剩下的没填入的字节数*/
            len -= ret;
        }
    }

    close(sfd);
    
    exit(0);
}
slowcat重构
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>

#define CPS     10
#define BUFSIZE CPS
#define BURST   100 


/*保证赋值操作一定是一条机器指令完成的*/
static volatile sig_atomic_t token = 0;

static void alarm_handler(int s)
{
    alarm(1);
    token++;
    if (token > 100)
    {
        token = BURST;
    }   
}

int main(int argc,char **argv)
{
    int sfd,dfd = 1;
    int ch,len,ret,pos = 0;
    char buf[BUFSIZE];

    if (argc < 2)
    {
        fprintf(stderr,"Usage : %s <source_filename> <dest_filename>\n",argv[0]);
        exit(1);
    }
    
    /*给SIGALRM发送信号*/
    signal(SIGALRM,alarm_handler);
    alarm(1);

    do
    {
        sfd = open(argv[1],O_RDONLY);
        if (sfd < 0)
        {
            if(errno != EINTR)
            {
                perror("open()");
                exit(1);
            }
        }
    } while (sfd < 0);
    

    while (1)
    {

        while(token <= 0)
            pause();//等待一个系统调用，暂时去掉盲等的情况。
        token--;

        /*len read 10 byte*/
        while(len = read(sfd,buf,BUFSIZE)<0)
        {
            if (errno == EINTR)
                continue;
            perror("read()");
            break;
        }
        if (len == 0)
            break;

        pos = 0;

        /*判断len是否全部填入*/
        while (len > 0)
        {
            /*from buf read len byte to dfd*/
            ret = write(dfd,buf+pos,len);
            if (ret < 0 )
            {
                if (errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            /*计算下一个写入的位置*/
            pos += ret;
            /*计算剩下的没填入的字节数*/
            len -= ret;
        }
    }

    close(sfd);
    
    exit(0);
}

pause();

abort();
给当前进程发送 abort信号。人为制造一个异常，杀掉当前进程得到出错的现场。

system();
调用shell完成shell。

sleep();
sleep有问题是因为sleep是 alarm和pause加起来封装的。当前没有错是因 为sleep使用nanosleep封装的。可以使用nanosleep，usleep替代。

usleep();
nanosleep();
select();

令牌桶
#ifndef MYTBF_H__
#define MYTBF_H__ 

#define  MYTBF_MAX  1024

typedef void mytbf_t;


mytbf_t *mytbf_init(int cps,int burst);

/*取令牌*/
int mytbf_fetchtoken(mytbf_t *,int );

/*归还令牌*/
int mytbf_returntoken(mytbf_t *,int );

int mytbf_destory(mytbf_t *);

#endif // DEBUG

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

static __sighandler_t alarm_handler_save;

static struct mytbf_st* job[MYTBF_MAX];

static int inited = 0;

struct mytbf_st
{
    int cps;//每秒传输的字节数
    int burst;//传输的上限
    int token;//令牌桶
    int pos;//下标
};

static void alarm_handler(int s)
{
    int i;

    alarm(1);

    for (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(void)
{
    int i;
    /*恢复功能*/
    signal(SIGALRM,alarm_handler_save);
    alarm(0);
    for (i = 0; i < MYTBF_MAX; i++)
        free(job[i]);
}

static void module_load(void)
{
    alarm_handler_save = signal(SIGALRM,alarm_handler);

    alarm(1);

    atexit(module_unload);
}

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

static int min(int a,int b)
{
    if (a<b)
        return a;
    return b;
}

mytbf_t *mytbf_init(int cps,int burst)
{
    struct mytbf_st *me;

    int pos;

    if (!inited)
    {
        module_load();
        inited = 1;
    }
       
    pos = get_free_pos();
    if (pos < 0)
        return NULL;
    
    me = malloc(sizeof(*me));
    if (me == NULL)
        return NULL;

    me->token = 0;
    me->cps = cps;
    me->burst = burst;
    me->pos = pos;

    job[pos] = me;

    return me;

}


/*取令牌*/
int mytbf_fetchtoken(mytbf_t *ptr,int size)
{
    struct mytbf_st *me = ptr;//指针转换

    int n;

    if (size <= 0)
       return -EINVAL;

    while(me->token <= 0)
        pause();//等待，阻塞的实现

    n = min(me->token,size);

    me->token -= n;

    return n;
    
}


/*归还令牌*/
int mytbf_returntoken(mytbf_t *ptr,int size)
{
    struct mytbf_st *me = ptr;//指针转换

    if (size <= 0)
       return -EINVAL;

    me->token += size;

    if (me->token > me->burst)
        me->token = me->burst;

    return size;
      
}

int mytbf_destory(mytbf_t *ptr)
{
    struct mytbf_st *me = ptr;//指针转换

    job[me->pos] = NULL;

    free(ptr);

    return 0; 
}


#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#include <time.h>
#include <errno.h>
#include "mytbf.h"

#define CPS     10
#define BUFSIZE 1024
#define BURST   100 

int main(int argc,char **argv)
{
    int sfd,dfd = 1;

    int size;

    int ch,len,ret,pos = 0;

    char buf[BUFSIZE];

    mytbf_t *tbf;


    if (argc < 2)
    {
        fprintf(stderr,"Usage : %s <source_filename> <dest_filename>\n",argv[0]);
        exit(1);
    }
    
    tbf = mytbf_init(CPS,BURST);
    if (tbf == NULL)
    {
        fprintf(stderr,"mytbf_init()failed\n");
        exit(1);
    }
    
    do
    {
        sfd = open(argv[1],O_RDONLY);
        if (sfd < 0)
        {
            if(errno != EINTR)
            {
                perror("open()");
                exit(1);
            }
        }
    } while (sfd < 0);
    

    while (1)
    {

        size =  mytbf_fetchtoken(tbf,BUFSIZE);
        if (size < 0)
        {
            fprintf(stderr,"mytbf_fetchtoken():%s\n",strerror(-size));

            exit(1);
        }
        
        /*len read 10 byte*/
        while(len = read(sfd,buf,size)<0)
        {
            if (errno == EINTR)
                continue;
            perror("read()");
            break;
        }

        if (len == 0)
            break;

        if (size - len>0)
            mytbf_returntoken(tbf,size-len);
        
        pos = 0;

        /*判断len是否全部填入*/
        while (len > 0)
        {
            /*from buf read len byte to dfd*/
            ret = write(dfd,buf+pos,len);
            if (ret < 0 )
            {
                if (errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            /*计算下一个写入的位置*/
            pos += ret;
            /*计算剩下的没填入的字节数*/
            len -= ret;
        }
    }

    close(sfd);
    
    mytbf_destory(tbf);

    exit(0);
}
anytime实现

.c文件

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#include <time.h>
#include <errno.h>
#include <sys/time.h>
#include "anytimer.h"

enum
{
    STATE_RUNNING = 1,
    STATE_CANCEL,
    STATE_OVER
};

struct at_job_st
{
    int job_state;
    
    int sec;
    
    int time_remain;

    at_addjob_t *jobp;

    void *arg;
};

static struct at_job_st *job[JOB_MAX];

static int inited = 0;

static struct sigaction alrm_sa_save;

static void alrm_action(int s,siginfo_t *infop,void *unused)
{
    int i;
    if (infop->si_code != SI_KERNEL)
        return;
    for ( i = 0; i < JOB_MAX; i++)
    {
        if(job[i]->job_state == STATE_RUNNING&&job[i]!=NULL)
        {
            job[i]->time_remain--;
            if(job[i]->time_remain == 0)
            {
                job[i]->jobp(job[i]->arg);
                job[i]->job_state = STATE_OVER;
            }

        }
    }
    
    


}

static void module_unload(void)
{
    struct sigaction sa,alrm_sa_save;

    struct itimerval itv;

    sa.sa_sigaction = alrm_action;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_SIGINFO;

    if (sigaction(SIGALRM,&sa,&alrm_sa_save)<0)
    {
        perror("sigaction()");
        exit(1);
    }
    itv.it_interval.tv_sec  = 1;
    itv.it_interval.tv_usec = 0;
    itv.it_value.tv_sec     = 1;
    itv.it_value.tv_usec    = 0;
    if (setitimer(ITIMER_REAL,&itv,NULL)<0)
    {
        perror("setitimer()");
        exit(1);
    }

}

static void module_load(void)
{   
    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);
  
    if (sigaction(SIGALRM,&alrm_sa_save,NULL)<0)
    {
        perror("sigaction()");
        exit(1);
    }

    atexit(module_unload);
}





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

int at_addjob(int sec,at_addjob_t *jobp,void* arg)
{
    int pos;

    struct at_job_st *me;

    //只调用一次函数
    if (!inited)
    {
        module_load();
        inited = 1;
    }

    pos = get_free_pos();
    if (pos<0)
        return -ENOSPC;
    
    me = malloc(sizeof(*me));
    if (me == NULL)
        return -ENOMEM;

    //初始化
    me->job_state = STATE_RUNNING;
    me->sec = sec;
    me->time_remain = me->sec;
    me->jobp = jobp;
    me->arg = arg;
    job[pos] = me;

    return pos;
    

}

int at_canceljob(int id)
{
    if (id < 0 || id>=JOB_MAX||job[id] == NULL)
        return -EINVAL;
    
    if (job[id]->job_state == STATE_CANCEL)
        return -ECANCELED;
    if (job[id]->job_state == STATE_OVER)
        return -EBUSY;
    
    job[id]->job_state = STATE_CANCEL;

    return 0;
}

int at_waitjob(int id)
{   
    if (id < 0 || id >= JOB_MAX||job[id] == NULL)
        return -EINVAL;
    while(job[id]->job_state == STATE_RUNNING)
        pause();
    if (job[id]->job_state == STATE_CANCEL||job[id]->job_state == STATE_OVER)
    {
        free(job[id]);
        job[id] = NULL;
    }    
}

.h文件

#ifndef MYTBF_H__
#define MYTBF_H__ 

#define JOB_MAX 1024 

typedef void at_addjob_t(void*);



int at_addjob(int sec,at_addjob_t *jobp,void* arg);
/*
* return >= 0 成功，返回任务ID
*        == -EINVAL 失败，参数非法
*        == -ENOSPC 失败，数组满
*        == -ENOMEM 失败，内存空间不足 
**/

int at_addjob_repeat(int sec,at_addjob_t *jobp,void* arg);
/*
* return >= 0 成功，返回任务ID
*        == -EINVAL 失败，参数非法
*        == -ENOSPC 失败，数组满
*        == -ENOMEM 失败，内存空间不足 
**/

int at_canceljob(int id);
/*
* return == 0 取消，指定任务成功取消
*        == -EINVAL 失败，参数非法
*        == -EBUSY  失败，任务已完成 
*        == -ECANCELED 失败，指定任务重复取消 
**/
int at_waitjob(int id);
/*
* return == 0 取消，指定任务成功释放
*        == -EINVAL 失败，参数非法
**/


#endif

main.c

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


static void f1(void *p)
{
    printf("f1():%s\n",p);
}

static void f2(void *p)
{
    printf("f2():%s\n",p);
}



int main(int argc,char **argv)
{
    int job1,job2,job3;

    puts("Begin!");

    job1 = at_addjob(5,f1,"aaa");
    if (job1 < 0)
    {
        fprintf(stderr,"at_addjob():%s\n",strerror(-job1));
        exit(1);
    }
    

    at_addjob(2,f2,"bbb");

    at_addjob(7,f1,"ccc");

    puts("End!");
    

}

7、信号集合

信号集类型:sigset_t

sigemptyset();
sigfillset();
sigaddset();
sigdelset();
sigismember();

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <signal.h>

void int_handler(int s)
{
    write(1,"!",1);
}

int main()
{
    int i,j;

    /*把打断信号忽略掉*/
    //signal(SIGINT,SIG_IGN);
    sigset_t set,oset,saveset;

    signal(SIGINT,int_handler);

    sigemptyset(&set);

    sigaddset(&set,SIGINT);

    sigprocmask(SIG_BLOCK,&set,&oset);
    
    for (j = 0; i < 1000; j++)
    {
            /*代码执行过程中，不受信号影响*/
            sigprocmask(SIG_BLOCK,&set,&oset);
            for (i = 0; i < 5; i++)
            {
                write(1,"*",1);
                sleep(1);
            }
            write(1,"\n",1);
            /*解除阻塞，返回之前的状态*/
            sigprocmask(SIG_SETMASK,&oset,NULL);
    }
    sigprocmask(SIG_SETMASK,&saveset,NULL);

    /*一头一尾表示进入这个状态和出去这个状态是没有影响的*/
    exit(0);
}

8、信号屏蔽字/pending集合的处理

sigprocmask();//相当于给一种机会来人为的控制mask。不能确定信号什么时候到来，但是可以确定信号什么时候被响应。
sigpending();//不知道用在什么环境下

9、扩展

sigsuspend();

信号驱动程序
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <signal.h>

void int_handler(int s)
{
    write(1,"!",1);
}

int main()
{
    int i,j;

    /*把打断信号忽略掉*/
    //signal(SIGINT,SIG_IGN);
    sigset_t set,oset,saveset;

    signal(SIGINT,int_handler);

    sigemptyset(&set);

    sigaddset(&set,SIGINT);

    sigprocmask(SIG_UNBLOCK,&set,&saveset);

    sigprocmask(SIG_BLOCK,&set,&oset);

    for (j = 0; i < 1000; j++)
    {
        /*代码执行过程中，不受信号影响*/
        
        for (i = 0; i < 5; i++)
        {
            write(1,"*",1);
            sleep(1);
        }
        write(1,"\n",1);
        sigsuspend(&oset);//相当于如下的原子操作。
        /*解除阻塞，返回之前的状态*/
        /*
        sigset_t tmpset;
        sigprocmask(SIG_SETMASK,&oset,&tmpset);
        pause();
        sigprocmask(SIG_SETMASK,&tmpset,NULL);
        */
    }
   sigprocmask(SIG_SETMASK,&saveset,NULL);

    exit(0);
}

sigaction();

setitimer();

守护进程的重构
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/types.h>
#include <fcntl.h>
#include <string.h>
#include <glob.h>
#include <syslog.h>
#include <errno.h>
#include <signal.h>

#define FNAME "tmp/out" 

static FILE *fp;
/*多个信号可以共用同一个信号处理函数*/
static void daemon_exit(int s)
{

    fclose(fp);
    closelog();
}

static int daemonize()
{
    pid_t pid;
    int fd;
    pid = fork();
    if (pid<0)
        return -1;

    
    if (pid>0)  //parent
    {
        exit(0);
    }
    fd = open("/dev/null",O_RDWR);
    if (fd<0)
        return -1;
    //将来要脱离控制终端的，0、1、2不需要关联设备，因此需要重定向。
    dup2(fd,0);
    dup2(fd,1);
    dup2(fd,2);
    if (fd > 2)
    {
        close(fd);
    }
    
    setsid();
    chdir("/");
    return 0;
}


int main()
{
    
    int i;
    //当你受到INTERRUPT这个信号的时候，就来执行 
    struct sigaction sa;
    sa.sa_handler = daemon_exit;
    __sigemptyset(&sa.sa_mask);
    __sigaddset(&sa.sa_mask,SIGQUIT);
    __sigaddset(&sa.sa_mask,SIGTERM);
    __sigaddset(&sa.sa_mask,SIGINT);
    sa.sa_flags = 0;

    sigaction(SIGINT,&sa,NULL);
    sigaction(SIGTERM,&sa,NULL);
    sigaction(SIGQUIT,&sa,NULL);
    

    openlog("mydaemon",LOG_PID,LOG_DAEMON);

    if (daemonize())
    {
        syslog(LOG_ERR,"daeonize() failed!");
        exit(1);
    }
    else
    {
        syslog(LOG_INFO,"daemonize() successded!"); 
    }
    
    fp = fopen(FNAME,"w");
    if (fp == NULL)
    {
        syslog(LOG_ERR,"fopen():%s",strerror(errno));
        exit(1);
    }

    syslog(LOG_INFO,"%s was opened.",FNAME);

    for (i = 0; ; i++)
    {
        
        fprintf(fp,"%d\n",i);
        fflush(fp);
        syslog(LOG_DEBUG,"%d is printed",i);
        sleep(1);
    }
    
    fclose(fp);
    closelog();
    
    exit(0);
}
令牌桶改装sigaction
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include <sys/time.h>
#include "mytbf.h"

static struct mytbf_st* job[MYTBF_MAX];

static int inited = 0;

static struct sigaitvction alrm_sa_save;

struct mytbf_st
{
    int cps;//每秒传输的字节数
    int burst;//传输的上限
    int token;//令牌桶
    int pos;//下标
};

static void alrm_action(int s,siginfo_t *infop,void *unused)
{

    int i;

    //alarm(1);

    if (infop->si_code != SI_KERNEL)
        return;
    

    for (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(void)
{
    int i;
    /*恢复功能*/
    struct itimerval itv;


    sigaction(SIGALRM,&alrm_sa_save,NULL);


    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 (i = 0; i < MYTBF_MAX; i++)
        free(job[i]);
}


static void module_load(void)
{

    struct sigaction sa;
    struct itimerval itv;


    sa.sa_sigaction = alrm_action;
    __sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_SIGINFO; 

    

    sigaction(SIGALRM,&sa,&alrm_sa_save);
    /*if error*/


    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);
    /*if error*/



    atexit(module_unload);
}

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

static int min(int a,int b)
{
    if (a<b)
        return a;
    return b;
}

mytbf_t *mytbf_init(int cps,int burst)
{
    struct mytbf_st *me;

    int pos;

    if (!inited)
    {
        module_load();
        inited = 1;
    }
    
    
    pos = get_free_pos();
    if (pos < 0)
        return NULL;
    
    me = malloc(sizeof(*me));
    if (me == NULL)
        return NULL;

    me->token = 0;
    me->cps = cps;
    me->burst = burst;
    me->pos = pos;

    job[pos] = me;

    return me;

}


/*取令牌*/
int mytbf_fetchtoken(mytbf_t *ptr,int size)
{
    struct mytbf_st *me = ptr;//指针转换

    int n;

    if (size <= 0)
       return -EINVAL;

    while(me->token <= 0)
        pause();//等待，阻塞的实现

    n = min(me->token,size);

    me->token -= n;

    return n;
    
}


/*归还令牌*/
int mytbf_returntoken(mytbf_t *ptr,int size)
{
    struct mytbf_st *me = ptr;//指针转换

    if (size <= 0)
       return -EINVAL;

    me->token += size;

    if (me->token > me->burst)
        me->token = me->burst;

    return size;      
}

int mytbf_destory(mytbf_t *ptr)
{
    struct mytbf_st *me = ptr;//指针转换

    job[me->pos] = NULL;

    free(ptr);

    return 0; 
}

10、实时信号

实时信号和标准信号。当信号同时发生的时候，先响应标准信号。

实时信号示例
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <signal.h>

#define  MYRTSIG (SIGRTMIN+6) 

void mysig_handler(int s)
{
    write(1,"!",1);
}

int main()
{
    int i,j;

    /*把打断信号忽略掉*/
    //signal(SIGINT,SIG_IGN);
    sigset_t set,oset,saveset;

    signal(MYRTSIG,mysig_handler);

    sigemptyset(&set);

    sigaddset(&set,MYRTSIG);

    sigprocmask(SIG_UNBLOCK,&set,&saveset);

    sigprocmask(SIG_BLOCK,&set,&oset);

    for (j = 0; i < 1000; j++)
    {
        /*代码执行过程中，不受信号影响*/
        
        for (i = 0; i < 5; i++)
        {
            write(1,"*",1);
            sleep(1);
        }
        write(1,"\n",1);
        sigsuspend(&oset);//相当于如下的原子操作。
        /*解除阻塞，返回之前的状态*/
        /*
        sigset_t tmpset;
        sigprocmask(SIG_SETMASK,&oset,&tmpset);
        pause();
        sigprocmask(SIG_SETMASK,&tmpset,NULL);
        */
    }
   sigprocmask(SIG_SETMASK,&saveset,NULL);

    exit(0);
}
梅山剑客
关注
专栏目录
Linux高并发服务器开发---笔记4（网络编程）
weixin_38665351的博客
07-20 3699
0705Linux高并发服务器开发—笔记1见Linux高并发服务器开发—笔记2见Linux高并发服务器开发—笔记3（多线程）视频课链接： 4.6 网络编程1 4.6 网络编程2计算机网络笔记 ②Linux简明系统编程（嵌入式公众号的课）—总课时12h 网卡是一块被设计用来允许计算机在计算机网络上进行通讯的计算机硬件，又称为网络适配器或网络接口卡NIC。其拥有 MAC 地址，属于 OSI 模型的第 2 层，它使得用户可以通过或相互连接。（即网卡分为以太网卡和无线网卡）每一个网卡都有一个被称为 MAC 地址的独
linux C 并发编程概念梳理
wwxy1995的博客
07-08 697
要讲清楚 IO 这坨东西. 将按如下章节说明。 1. user space & kernel space 2. multiplexing （select ， epoll，AIO[reactor & proactor ] ） 3. 各种 IO 的名称 4. 结语 user space & kernel space 这两跟 IO 有很密切的关系。所以放在最前面...
linuxc高并发服务器
11-28
在linux下采用epoll的方式用C实现高斌发服务器，直接编译可以运行
LinuxC应用开发学习笔记（十二）—并发（线程）
梅山
01-06 917
线程 1、线程的概念 一个正在运行的函数 线程间通信会比进程间通信简单点。 posix线程是一套标准，而不是实现。 openmp线程 线程标识：pthread_t (理解为一个整型数) ps下面的 - - 是线程。进程来消耗当前的进程号的。进程就是容器用来承载线程。 pthread_equal()；//比较线程标识 pthread_self();//返回当前线程标识 2、线程的创建 pthread_create(); 线程的调度取决于调度器调度。 #include <stdio.h> #inc
Linux C并发控制
雷连杰的技术博客
07-30 282
Linux线程接口也称为pthread或POSIX线程，Linux2.6以后，采用Native POSIX线程库的新线程实现。 1， 互斥量     头文件&lt;pthread.h&gt; pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;     静态分配：     pthread_mutex_t mtx = PTHREAD_MUTEX...
linux c 网络编程 并发
xiaopohaibebo的专栏
08-16 3861
[精华] Linux下各类TCP网络服务器的实现源代码 -------------------------------------------------------------------------------- http://www.chinaunix.net 作者:zhoulifa 发表于：2006-07-11 22:53:24 【发表评论】【查看原文】【Linux讨论区】【关闭】
linux高编信号-------并发
weixin_33757911的博客
02-22 105
1.信号：是软件层面的中断。 　　异步事件的处理：查询法，通知法； 　　同步： 　　信号的响应依赖于中断； 2.signal(); 3.信号的不可靠 4.可重入函数 5.信号的响应过程 6.相关的常用函数 发送信号 kill() raise() alarm() pause） abort() system() sleep() 7.信号集 8.信号屏蔽字和信号pen...
Linux多线程编程_linux多线程_Linux多线程；应用笔记_columnc9g_
10-03
在Linux系统中，多线程编程是...通过学习和实践Linux多线程编程，开发者可以构建出高效、健壮的并发应用程序，满足高并发场景的需求。在实际开发中，理解并掌握上述知识点至关重要，同时也需要注意线程安全和性能优化。
linux编程学习笔记PDF资料下载.txt
07-17
根据提供的文件信息，我们可以推断出这是一份关于Linux编程学习笔记的PDF资料。下面将对这份资料可能涉及的关键知识点进行详细的阐述。 ### Linux编程基础知识 #### 1. Linux操作系统概述 - **定义与特点**：Linux...
Linux系统编程学习笔记
最新发布
02-07
### Linux系统编程学习笔记 #### 一、IO **1.1 标准I/O (stdio)** - **fopen/fclose**: `fopen` 用于打开或创建一个文件，并返回一个指向该文件的 `FILE *` 类型的指针。`fclose` 用于关闭由 `FILE *` 指向的文件...
【精通内核】Linux内核并发控制原理信号量与P-V原语源码解析
小明的Java问道之路
09-18 1076
本文深入Linux内核源码，从核心源码入口讲起，详细对信号量、互斥量的内核代码讲解，其中对P-V操作实现逐行剖析，Linux内核并发控制原理的锁实现和原理在后续文章中一一讲解，本文深入浅出Linux中断控制的实现原理。
Linux多线程并发C/S模型
陈常杰的博客
08-02 276
服务端： /************************************************************************* > File Name: server.c > Author: ma6174 > Mail: ma6174@163.com > Created Time: 2020年08月02日 星期日 14时44分18秒 ******************************************************
linux并发机制Ⅲ---信号量机制分析
05-19 593
1概述 信号量semaphore，是操作系统中一种常用的同步与互斥的机制； 信号量允许多个进程（计数值>1）同时进入临界区； 如果信号量的计数值为1，一次只允许一个进程进入临界区，这种信号量叫二值信号量； 信号量可能会引起进程睡眠，开销较大，适用于保护较长的临界区； 与读写自旋锁类似，linux内核也提供了读写信号量的机制； 2信号量 2.1 流程分析 可以将信号量比喻成一个盒子，初始化时在盒子里放入N把钥匙，钥匙先到先得，当N把钥匙都被拿走完后，再来拿钥匙的人就需要等待了，只有等...
linux多线程学习(六)——信号量实现同步。
阿堂的专栏
01-19 5398
在上一篇文章中已经用信号量来实现线程间的互斥，达到了互斥锁的效果，今天这篇文章将讲述怎样用信号量去实现同步。信号量的互斥同步都是通过PV原语来操作的，我们可以通过注册两个信号量，让它们在互斥的问题上互动，从而达到同步。通过下面实例就可以很容易理解： #include #include #include #include #include #inc
Linux下C语言管理多个信号并发
05-29 261
linux C语言使用IO复用处理信号 一、为什么要使用IO复用的方式管理信号？ 考虑这样一个场景，事实上经常会遇到这种场景。 设备中存在一个守护进程A。 设备中存在一个用户进程，B。B在某些情况下需要重启日志服务。 如果要B自己来处理这个需求，必须使用系统调用。system();函数。 使用system函数重启了日志服务之后，日志服务进程的父进程就是B。此时，B因为其它的原因，需要重新启动，重新加载参数。 此时，B死亡前，可能没法处理日志服务。这种做法是十分不合理的。一个服务的父进
Linux进程通信之信号量 控制进程同步
weixin_50803498的博客
03-26 855
信号量、信号量接口函数、semget函数、semctl函数、semop函数、ipcs 可以查看消息队列、共享内存、信号量的使用情况，使用 ipcrm 可以进行删除操作。
Unix环境高级编程-信号详解
NINE_world的博客
01-15 642
信号 信号是初步异步，线程是强烈异步 两者机制很少混合使用，仅仅会将少量的信号混入 同步： 顺序执行，可预知 异步： 哪个事件什么时候到来不确定，产生什么样的结果也不确定 异步事件的处理： 查询法：适合事件发生频率比较高 通知法：适合事件发生频率比较稀疏 一、信号 1、信号的概念- 信号是软件层面的中断 信号的响应依赖与中断机制 多半的信号的作用都是终止，或者终止+core 标准C里面的信号基本是摆设 core文件就是出错现场，利于找出程序错误 2、signal()； NAME
信号的响应过程分析
m0_55045698的博客
05-28 166
但是进程x是不知道有信号的，只有发生某种中断时（例如时间片耗尽），进程进入了内核空间，重新分配时间片有执行权时，进程x会执行一个由内核态变为用户态的变态过程，这个时候就会mask&pending，如果按位与出来的值为1，就会将当初中断时保存下来的运行环境中的一个add..指针指向关于信号处理的函数，同时将mask和pending对应的值变为0。这个时候，如果有信号传来又将pending其中的值变为1，就会重复进行上述操作，否者按位与出来的值就是0，就会回到用户态，开始执行中断后的后续代码。
问题：Linux 信号处理，当连续给一个进程同时发送多个信号时，部分信号丢失而未得到处理
在巴黎铁塔 :-)
04-09 3182
参考链接 - linux 信号signal和sigaction理解（该文章解释了：< 实验 1 中连续多个相同信号处理问题 >，以及 < 实验 2/3 中使用 sigaction 信号屏蔽字解决信号处理函数竞态问题 > ） 连续给一个进程发送多个相同信号时，部分信号丢失而未得到处理（使用 signal 函数处理信号），代码如下： /* test2.c */ #inclu...
Linux进程理解与嵌入式学习笔记
"进程与程序的区别，动态电压恢复器的补偿策略，Linux内核中的task_struct，进程状态...这份资料涵盖了从基础的C语言编程到深入的Linux系统编程，特别是进程和线程管理的知识，是学习嵌入式Linux系统开发的宝贵资源。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值