令牌桶 -- alarm信号、漏桶、alarm信号实现的令牌桶、使用alarm信号将令牌桶封装成库、互斥量重新实现令牌桶、使用条件变量修改并实现令牌桶

最新推荐文章于 2022-05-17 20:47:06 发布
最新推荐文章于 2022-05-17 20:47:06 发布
阅读量522 收藏 2
点赞数 2
文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuechanba/article/details/119903937
版权

alarm()

一个信号从发出到收到，有一个不可避免的时延。所以如果使用信号来计时的话,10ms以内的计时不准确。只要超过这个时间，基本上都能准确的用信号来计时。

alarm没有办法直接实现多任务的计时器，因为当程序中有多个alarm时，程序计时可能就会以最后一个alarm为准，所以alarm不能直接用于多任务的计时器。因此，我们需要思考怎么使用alarm这样一个单一的计时器来实现10秒做一个事，5秒做一个事，1秒做一个事的多任务计时器。

pause()

NAME
       pause - wait for signal

SYNOPSIS
       #include <unistd.h>

       int pause(void);

DESCRIPTION
       pause()  causes the calling process (or thread) to sleep until a signal is delivered that either terminates the process or causes the invocation of asignal-catching function.
       Pause()导致调用(当前正在运行的)进程(或线程)进入休眠状态，直到发送了终止进程或调用信号捕获函数的信号。

我们需要强调的是，有时我们使用sleep延时虽然能实现我们想要的效果，但是sleep只能用来调试，不能用到发布的源码当中，原因是sleep对于不同的平台并不通用，在有的平台上面sleep是由alarm和pause两者封装在一起实现的，假如在你当前程序中还有一个alarm，那么是不是就修改了我当前的定时时间，程序功能是不是就有问题了。也就是说sleep不具有兼容性。

下面，我们来使用alarm做一个定时循环的实验（一个程序疯狂的跑5s）。

第一个版本，使用time函数来实现

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    time_t end;
    int64_t count=0;//为了防止溢出，使用64位的整型数来计时

    //当前的时间戳 + 5
    end =time(NULL)+5;

    //也就是计时5s
    while(time(NULL)<=end)
    {
        count++;
    }

    printf("%ld\n",count);
    return 0;
}

运行时，我们使用time命令来统计程序的实际运行时间，并把结果输出到当前目录下的log文件中。
在这里插入图片描述
系统会从按时间那一刻开始计算，会把5.001s – 5.9999s都看作是5s的时间。这样一看，这个误差比例还是挺高的，近乎相差1s。但如果计时时间越长，比如计时10000s，误差也是相差1s，从这方面来看，误差比例就相对小很多了。

第二个版本，使用信号alarm函数来实现

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

int loop = 1;

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

int main()
{
    int64_t count=0;//为了防止溢出，使用64位的整型数来计时
    
    signal(SIGALRM,alarm_handler);
    alarm(5);

    //也是计时5s
    while(loop)
    {
        count++;
    }

    printf("%ld\n",count);

    return 0;
}

程序中的语句
signal(SIGALRM,alarm_handler);
一定要放在
alarm(5);
之前。

同样，运行时，我们使用time命令来统计程序的实际运行时间。
在这里插入图片描述
real 时间= user时间 +sys时间，我们看user的时间。

可以看出，使用alarm控制的时间更精确。

漏桶

流控（流量控制）：每秒钟按规定的字符输出。（音、视频播放器中每秒播放多少字节，网络传输中，每秒固定传输多少字节的内容中广泛应用。）

这里要实现的一个具体的功能是：

实现cat的功能，但是将一次性显示改成每秒显示固定个数的字符。

实现效果如下：
请添加图片描述
使用sleep延时来实现

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

//每秒传输的字符的个数
#define CPS     10
#define BUFSIZE CPS

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

    if(argc < 2)
    {
        fprintf(stderr,"Usage...\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)
    {
        len = read(sfd,buf,BUFSIZE);
        if(len < 0)
        {
            if(errno == EINTR)
                continue;
            perror("read()");
            break;
        }
        if(len == 0)
        {
            break;
        }
        pos = 0;
        while(len > 0)
        {
            ret = write(dfd,buf+pos,len);
            if(ret < 0)
            {
                if(errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            pos += ret;
            len -= ret;   
         }
        sleep(1);//等待1s
    }

    close(sfd);

    return 0;
}

需要说明的是，使用sleep延时虽然能实现想要的效果，但是sleep只能用作调试来用，不能用到发布的源码当中，原因是sleep对于不同的平台并不通用，不具有兼容性。

因此，下面我们用alarm()函数来实现

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

//每秒传输的字符的个数
#define CPS     10
#define BUFSIZE CPS

static volatile int loop = 1;

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

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

    if(argc < 2)
    {
        fprintf(stderr,"Usage...\n");
        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)
    	{
    		//等待SIGALRM信号的到来,程序才继续执行。有点类似于sleep。
    		//可避免忙等（什么都不做）。
    		 pause();
    	}
    	loop = 0;
    
        while((len = read(sfd,buf,BUFSIZE))<0)
        {
             //如果是假错，比如遇到中断
              if(errno == EINTR)
              //就跳出当前循环体,重新执行当前层的while循环
                  continue;
             //如果是真错，就退出循环体
            perror("read()");
            break;
         }
         
        if(len == 0)
        {
            break;
        }
        
        pos = 0;
        while(len > 0)
        {
            ret = write(dfd,buf+pos,len);
            if(ret < 0)
            {
                if(errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            pos += ret;
            len -= ret;
        }
    }

    close(sfd);
    
    return 0;
}

从上面的实现来看，我们可以发现我们所实现的这个漏桶功能的特点是，假设我们从一个（设备）文件中读数据，不管数据量来的很小还是数据量特别大的时候，程序都是一秒钟不紧不慢的最多输出10个字节大小的数据，这样就显得不够灵活。

令牌桶

令牌桶的功能相比于漏桶更加灵活，程序可以在漏桶的基础上进行修改，我们漏桶的权限是每间隔1秒最多能输出10个字节大小的数据，我们想改成当读数据时，没有读到数据的时候就攒权限，当数据量大的时候，就可以根据积攒的权限多输出一些数据。这样也可以避免像漏桶那样一直在忙等。

比如还是一秒钟能输出10个字节的数据，现在，没读到数据，我们就开始积攒权限，假设积攒三秒，就积攒到了连续三次输出10个字节的数据量。

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

//每秒传输的字符的个数
#define CPS     10
#define BUFSIZE CPS
//规定一个上限，权限(令牌)不能一直积攒
#define BURST   100

//token -- 令牌
static volatile int token = 0;
//如果程序一开始就输出数据，就让token=1，
//如果一开始就让它积攒权限，1秒后再输出，就让token=0
//如果模拟等待一段时间，token积攒到某个数值时，突然有
//大量数据来的的输出效果，就给token>1的初始值

static void alarm_handler(int s)
{
    alarm(1);
    token++;
    if(token > BURST)//如果token的值大于上限
        token = BURST;//让token的值保持在上限不动
}

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

    if(argc < 2)
    {
        fprintf(stderr,"Usage...\n");
        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(token <= 0)
            pause();
        //读写一圈消耗一个token
        token-=1;

        //假设这里读打印机数据，一开始没读到数据，会阻塞到这，恰好1s时间到了,
        //被信号打断，程序会执行alarm信号指定的函数,token++,执行完之后，程序返回到这里，
        //就会被判断为假错，然后重新执行while循环,当仍然没有读到数据,循环上述步骤。
        //假设在第三秒后，数据来了，此时token = 3。
        while((len = read(sfd,buf,BUFSIZE))<0)
        {
            //如果是假错
            if(errno == EINTR)
            //就跳出当前循环体,重新执行while循环
                continue;
            //如果是真错，就退出循环体
            perror("read()");
            break;
        }

        if(len == 0)
        {
            break;
        }
        //接上面的分析
        //程序开始写数据，每次仍然写10个字节大小的数据，因为有充足的token，所以可以
        //连续的写，而不需要靠执行信号捕获函数来积攒token,这样就给人一种一
        //次读写多个字节大小的数据的感觉。
        pos = 0;
        while(len > 0)
        {
            ret = write(dfd,buf+pos,len);
            if(ret < 0)
            {
                if(errno == EINTR)
                    continue;
                perror("write()");
                exit(1);
            }
            pos += ret;
            len -= ret;
        }
	}
	
    close(sfd);

    return 0;
}

令牌桶封装成库

令牌桶的要素:
在这里插入图片描述
1、我们需要指定不同的流速（CPS）
2、每个令牌桶的令牌个数一定有一个上限（BURST）
3、还要有一个变量来存放当前的令牌数。(token)

令牌桶封装成结构体，挂接在数组中。

在函数功能上，原先的
" 一个token一次能输出cps个字符，一次加1个token "
改写成
“一个token一次能输出一个字符，每次加cps个token”
在这里插入图片描述
最关键的问题是，捋着数组走，给每个非空的令牌桶都加上token。初始的alarm只能执行一次。

token.h

封装的很彻底

#ifndef _TOKEN_H_
#define _TOKEN_H_

//最多能支持1024个不同速率的令牌桶
#define MYTBF_MAX 1024

typedef void  mytbf_t;
//void* 赋值给任何类型的指针都天经地义
//任何类型的指针赋值给void*也都天经地义

//用户指定令牌桶的每秒传输速率和令牌上限
//实际上应该是struct mytbf_st *mytbf_init(int cps,int burst);
mytbf_t *mytbf_init(int cps,int burst);//一定会申请空间

//使用令牌桶，无非两个动作
//1、取令牌，取了多少通过返回值返回
int mytbf_fetchtoken(mytbf_t*, int);

//2、取多了，要还回去，还回去多少，也要以返回值形式返回
int mytbf_returntoken(mytbf_t*,int);


int mytbf_destory(mytbf_t*);//释放空间

#endif

token.c

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

#include "token.h"

typedef void (*sighandler_t)(int);

static int inited = 0;
static sighandler_t alarm_handler_save;

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

//结构体指针数组
static struct mytbf_st* job[MYTBF_MAX];

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)
{
    //从全局考虑，程序作为一个模块被加载到一个工程中
    //别人出去不再使用alarm时钟，所以我们在退出后，
    //还原信号原有的行为，要将alarm关闭。

    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的新行为
    alarm_handler_save = signal(SIGALRM,alarm_handler);
    alarm(1);

    //钩子函数-程序正常终止，调用module_unload
    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;
}

mytbf_t *mytbf_init(int cps,int burst)
{
    struct mytbf_st* mytbf;
    int pos=0;

    if(!inited)
    {
        module_load();
        inited = 1;
    }

    //找出结构体指针数组中的空位，如果找到了返回下标
    pos = get_free_pos();
    if(pos < 0)
    {
        return NULL;
    }

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

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

    return mytbf;
}

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

int mytbf_fetchtoken(mytbf_t* ptr, int size)
{
    int n;
    struct mytbf_st *mytbf = ptr;

    if(size<=0)
    {
        //参数非法
        return -EINVAL;
    }

    //我当前也没有token
    while(mytbf->token <= 0)
    {
        pause();
    }

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

    mytbf->token-=n;

    return n;
}

//2、多了，要还回去，还回去多少，也要以返回值形式返回
int mytbf_returntoken(mytbf_t* ptr,int size)
{
    struct mytbf_st *mytbf = ptr;

    if(size <=0)
    {
        //参数非法
        return -EINVAL;
    }

    mytbf->token+=size;

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

    return size;
}

//ptr是void*类型
int mytbf_destory(mytbf_t* ptr)//释放空间
{
    struct mytbf_st *mytbf = ptr;
    job[mytbf->pos]=NULL;

    if (ptr != NULL)
    {
        free(ptr);
        ptr = NULL;
    }

    mytbf = NULL;
}

main.c

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

#include "token.h"

//每个令牌对应的能传输的字符的个数
#define CPS     10
//想要申请的令牌数
#define BUFSIZE 1024
//规定一个上限，权限(令牌)不能一直积攒
#define BURST   1024

int main(int argc,char* argv[])
{
    int sfd,dfd=1;
    char buf[BUFSIZE];
    int len,ret,pos;
    int size;
    mytbf_t *tbf = NULL;

    if(argc < 2)
    {
        fprintf(stderr,"Usage...\n");
        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)
    {
        //我想要BUFSIZE个令牌
        size = mytbf_fetchtoken(tbf,BUFSIZE);
        if(size < 0)
        {
            fprintf(stderr,"mytbf_fetchtoken():%s.\n",strerror(-size));
            exit(1);
        }

        //能获得多少个令牌，我就先读多少个字节
        //len是实际读到的字节数
        while((len = read(sfd,buf,size))<0)
        {
            //如果是假错
            if(errno == EINTR)
            //就跳出当前循环体,重新执行while循环
                continue;
            //如果是真错，就退出循环体
            perror("read()");
            break;
        }

        //读到文件的末尾就直接退出
        if(len == 0)
        {
            break;
        }
        //如果还剩token，就返还回去。
        if(size-len >0)
        {
            mytbf_returntoken(tbf,size-len);
        }

        pos = 0;
        while(len > 0)
        {
            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);

    tbf = NULL;
    return 0;
}

makefile

token:main.o token.o
    gcc -o token $^

%.o: %.c
    gcc -c -o $@ $<

clean:
    rm *.o token

.PHONY:clean

互斥量实现的令牌桶

为什么说对job数组操作应该使用互斥量（加锁）呢？

想象一下，当前有多个线程几乎同时在操作mytbf_init这个函数，那么他们都会去找出结构体指针数组job中的空位，那么势必会产生竞争。因此，对job数组操作应该使用互斥量（加锁）。

应该定义成什么性质的互斥量呢？
应该定义成一个(全局)互斥量，相当于1024个令牌桶在用同一把锁。

对于job数组来说，使用同一把锁是合适的。

但对于同一个令牌桶来说，创建出来的线程每过一秒会加token，而main线程也会执行加token或减token，这势必会产生竞争，因此也需要使用互斥量。

那这个互斥量应该定义成全局的吗？

这个不合适的，因为对于不同的令牌桶来说，加token和减token是不相关的，因此，再用同一把锁就不合适了。

动态模块的单次初始化函数

NAME
       pthread_once - once-only initialization
       对某个模块执行单次初始化

SYNOPSIS
       #include <pthread.h>

       pthread_once_t once_control = PTHREAD_ONCE_INIT;
		
       int pthread_once(pthread_once_t *once_control, void (*init_routine) (void));

即使在mian函数中有两个线程来调 mytbf_init 或 执行两次 mytbf_init，mytbf_init 也只被调一次。操作的都是同一个job数组。

上面的mian.c和token.h都不用改动。只需要修改token.c文件和makefile文件。

token.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <string.h>

#include "token.h"

pthread_t tid_alarm;

static pthread_once_t once_control = PTHREAD_ONCE_INIT;

struct mytbf_st
{
    int cps;
    int burst;
    int token;
    int pos;
    pthread_mutex_t mut_token;
};

//应该做为一个独占的资源被使用
//结构体指针数组
static struct mytbf_st* job[MYTBF_MAX];

//定义一个互斥量,要通过名字来体现是对谁的限制和约束
static pthread_mutex_t mut_job = PTHREAD_MUTEX_INITIALIZER;

//把时间到了，加token这个函数用一个线程来完成
static void* thr_alarm(void* p)
{
    int i;
	
	while(1)
    {
        //进入楼层后，先锁整栋楼的门,再锁每个房间的门
        //离开楼层后，先开每个房间的门,再开整栋楼的门
        pthread_mutex_lock(&mut_job);
        for(i=0;i<MYTBF_MAX;i++)
        {
            if(job[i] != NULL)
            {
                pthread_mutex_lock(&job[i]->mut_token);
                job[i]->token +=job[i]->cps;
                if(job[i]->token >= job[i]->burst)
                    job[i]->token = job[i]->burst;
                pthread_mutex_unlock(&job[i]->mut_token);
            }
        }
        pthread_mutex_unlock(&mut_job);
        sleep(1);//1秒钟做一次,调试时可用,发布时应使用更安全的延时1s的函数.
    }
}

static void module_unload(void)
{
    int i;

    //因为线程在执行一个死循环,不会返回,所以要先给该线程给取消
    pthread_cancel(tid_alarm);
    //再回收,不关心退出线程退出时的状态.
    pthread_join(tid_alarm,NULL);

    //程序正常终止，将没有释放的内容给释放掉
    for(i=0;i<MYTBF_MAX;i++)
    {
        if(job[i]!=NULL)
        {
            mytbf_destory(job[i]);
        }
    }

    //互斥量mut_job一定是在模块卸载时销毁
    pthread_mutex_destroy(&mut_job);
}

static void module_load(void)
{
    int err;

    //创建线程
    err = pthread_create(&tid_alarm,NULL,thr_alarm,NULL);
    if(err)
    {
        fprintf(stderr,"pthread_creat() %s.\n",strerror(err));
        exit(1);
    }
    //钩子函数---程序正常终止，调用module_unload
    atexit(module_unload);
}

//两个人同时调用get_free_pos,有可能找到同一个空闲的下标，从而发生冲突
//从名字上体现出未加锁版本,但你要使用它,请加锁之后再调用.
static int get_free_pos_unlocked(void)
{
    int i;

    //理论上,你在查看job[i]数组,是不是应该加锁
    //但是,别忘了,你是怎么到这个函数这的,你是
    //加了锁之后,然后来到这儿的,如果在这要加锁，
    //就形成了二次加锁,虽然,互斥量有一个属性可以让我们
    //二次加锁成功,但是这里是不符合的,另外,程序中没有人在别的地方
    //调用这个函数。所以加锁是没有必要的,但我们要在函数名称上
    //给出提示,表明这个函数是没有加锁的,但你如果要使用这个函数,
    //请先加锁再使用这个函数。
    for(i=0;i<MYTBF_MAX;i++)
    {
        if(job[i]==NULL)
        {
            return i;
        }
    }

    return -1;
}

mytbf_t *mytbf_init(int cps,int burst)
{
    struct mytbf_st* mytbf;
    int pos=0;

    //假设有两个线程前后脚来调用mytbf_init这个函数
    //几乎同时来判断inited这个全局变量的值,结果两个
    //线程的inited都为零,结果都能执行module_load()
    //这显然是不可以的。

    /*
    if(!inited)
    {
         module_load();
         inited = 1;
    }
    */

    //那有解决的方法吗？
    //1、再次加锁
    //2、使用模块的单次初始化函数pthread_once
    pthread_once(&once_control, module_load);

    //都跟job数组没有关系,因此可以放在临界区外面来实现
    mytbf = malloc(sizeof(*mytbf));
    if(mytbf == NULL)
    {
        return NULL;
    }
    mytbf->token = 0;
    mytbf->cps = cps;
    mytbf->burst = burst;
    //初始化结构体的成员互斥量mut_token
    pthread_mutex_init(&mytbf->mut_token,NULL);

    //找出结构体指针数组中的空位，如果找到了返回下标
    pthread_mutex_lock(&mut_job);
    //尝试对临界区进行优化，临界区应该越短越好
    //尝试对临界区进行优化，临界区应该越短越好
    //临界区内的函数跳转也是一个问题,比如下面的get_free_pos永远也回不来,程序也将死锁
    pos = get_free_pos_unlocked();
	if(pos < 0)
    {
        pthread_mutex_unlock(&mut_job);
        //临界区内的任何一个跳转语句一定要记得解锁之后再跳转,
        //否则你跳转了,一直没解锁,别人也就一直进不去
        free(mytbf);
        mytbf = NULL;

        return NULL;
    }

    mytbf->pos =pos;

    job[pos]=mytbf;
    pthread_mutex_unlock(&mut_job);

    return mytbf;
}

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

int mytbf_fetchtoken(mytbf_t* ptr, int size)
{
    int n;
    struct mytbf_st *mytbf = ptr;

    if(size<=0)
    {
        //参数非法
        return -EINVAL;
    }

    //查看我当前有没有token
    //要加锁查看
    pthread_mutex_lock(&mytbf->mut_token);
    while(mytbf->token <= 0)
    {
        //不满足条件，就先解锁
        pthread_mutex_unlock(&mytbf->mut_token);
        //等待--短暂出让调度器
        sched_yield();
        //再抢锁，此时发现大于0,退出循环体，向下执行
        pthread_mutex_lock(&mytbf->mut_token);
    }

    n = min(mytbf->token,size);
    //当程序执行到这想加token,但另一个线程恰好想要减token,
    //就会引起竞争和冲突,因此仍然需要使用到互斥量,但是这个互斥量
    //的定义需要来分析下.能否和上面定义的一样使用全局互斥量呢?

    mytbf->token-=n;
    //对token的操作到此为止,将其解锁
    pthread_mutex_unlock(&mytbf->mut_token);

    return n;
}

//2、多了，要还回去，还回去多少，也要以返回值形式返回
int mytbf_returntoken(mytbf_t* ptr,int size)
{
    struct mytbf_st *mytbf = ptr;

    if(size <=0)
    {
        //参数非法
        return -EINVAL;
    }

    pthread_mutex_lock(&mytbf->mut_token);
    mytbf->token+=size;

    if(mytbf->token > mytbf->burst)
        mytbf->token = mytbf->burst;
    pthread_mutex_unlock(&mytbf->mut_token);

    return size;
}

//ptr是void*类型
int mytbf_destory(mytbf_t* ptr)//释放空间
{
    struct mytbf_st *mytbf = ptr;

    pthread_mutex_lock(&mut_job);
    job[mytbf->pos]=NULL;
    pthread_mutex_unlock(&mut_job);

    //因为这个互斥量是结构体成员变量，
    //所以要在释放内存区域之前回收。
    pthread_mutex_destroy(&mytbf->mut_token);

    if (mytbf != NULL)
    {
        //释放令牌桶空间
		free(mytbf);
        mytbf = NULL;
    }
}

makefile

CFLAGS+=-pthread
LDFLAGS+=-pthread

all:token

token:main.o token.o
    gcc -o token $^ $(LDFLAGS)

%.o: %.c
    gcc $(CFLAGS) -c -o $@ $<

clean:
    rm *.o token

.PHONY:clean

使用条件变量修改并实现令牌桶

我们上面写的是忙等版本，忙在那呢？

忙在函数 mytbf_fetchtoken 中的这一段

//查看我当前有没有token
//要加锁查看
pthread_mutex_lock(&mytbf->mut_token);
while(mytbf->token <= 0)
{
    //不满足条件，就先解锁
    pthread_mutex_unlock(&mytbf->mut_token);
    //等待--短暂出让调度器
    sched_yield();
    //再抢锁，此时发现大于0,退出循环体，向下执行
    pthread_mutex_lock(&mytbf->mut_token);
}

我一秒钟会在这个地方执行上亿次，不停的加锁查看我当前有没有token，，解锁等待。
那我们能不能利用条件变量将其改成通知机制呢？

可以的，我们可以在while循环中使用函数pthread_cond_wait来等待当前token的值发生变化。但要和线程消息函数pthread_cond_broadcast或pthread_cond_signal相互配合，具体使用pthread_cond_broadcast还是使用
pthread_cond_signal，稍后分析。此外，我们还要分析pthread_cond_wait这个函数为什么能够实现这一目的。

但在做这些之前，我们需要使用条件变量的动态定义方式来初始化条件变量。因为，我们要控制的是每个令牌桶（结构体）中的token值，所以，我们也要在结构体中注册这一变量。

struct mytbf_st
{
    int cps;
    int burst;
    int token;
    int pos;
    pthread_mutex_t mut_token;
    pthread_cond_t mytbf_cond;
};

接着，我们要在init函数中进行初始化。

mytbf_t *mytbf_init(int cps,int burst)
{
	......
	......
	mytbf->burst = burst;
    pthread_mutex_init(&mytbf->mut_token,NULL);
    //采用默认属性,填NULL
    pthread_cond_init(&mytbf->cond, NULL;
    ......
    ......
}

之后，还要在destory函数中销毁，代码如下。

//ptr是void*类型
int mytbf_destory(mytbf_t* ptr)//释放空间
{
    ......
    pthread_mutex_destroy(&mytbf->mut_token);
	pthread_cond_destroy(&mytbf->cond);
  	......
}

我们再回到mytbf_fetchtoken函数。

int mytbf_fetchtoken(mytbf_t* ptr, int size)
{
......
......
//查看我当前有没有token
//要加锁查看
pthread_mutex_lock(&mytbf->mut_token);
while(mytbf->token <= 0)
{
/*
    //不满足条件，就先解锁
    pthread_mutex_unlock(&mytbf->mut_token);
    //等待--短暂出让调度器
    sched_yield();
    //再抢锁，此时发现大于0,退出循环体，向下执行
    pthread_mutex_lock(&mytbf->mut_token);
*/

//使用pthread_cond_wait函数就相当于上面的三个步骤
//为什么呢？注意该函数的两个参数.
    pthread_cond_wait(&mytbf->cond,&mytbf->mut_token);
//pthread_cond_wait在这里的功能是发现循环条件不成立,就解锁等待,等到什么时候,
//等到有pthread_cond_broadcast或pthread_cond_signal发来消息.
//broadcast和signal的区别是叫醒全部等待和叫醒任意一个等待.
//所以pthread_cond_wait一定是和一个或多个broadcast或signal相对应的.
//注意：等待是解锁等待.就相当于上面代码中的先解锁后短暂让出调度器,但不是sched_yield,
//而是一个等broadcast或signal.(是在临界区外等待),当有broadcast或signal叫醒它后,它起来的
//第一反应是抢锁,然后再来查看条件是否成立.而不是直接向下运行的.如果没抢到锁,锁被别人抢走
//了,当前这个wait原语就会被堵塞在抢锁阶段,直到别人让出锁,它再抢到锁.
......
......
}

那么谁会来打断呢，我们要的是改变token，token在哪些地方会改变呢？

在线程函数thr_alarm这，每过一秒钟，给所有非空的令牌桶加token。
还有返还token函数mytbf_returntoken这，当使用完之后，还剩余token的话，会还token。

首先来看线程函数thr_alarm这

我们在该函数中添加pthread_cond_broadcast或pthread_cond_signal，在哪添加呢？添加哪一个呢？

使用pthread_cond_broadcast可以叫醒所有正在等待的线程。
使用pthread_cond_signal叫醒哪一个等待的线程是随机的，是不确定的。

我们可能会这样想。
我们在给第i个令牌桶加token，那么使用signal给这个等待给唤醒不就好了吗？但是，这是不对的，因为会有这么一种情况，假设有多个令牌桶，他们恰好都停留在取token的阶段(多个线程同时都在等待)，都在等待着信号给他们给叫醒，但是使用signal叫醒又是随机的，不确定它会叫醒哪一个，假设第三个令牌桶需要等待信号，但你signal却偏偏独爱其他几个，每次都不给第三个发。

所以，我们使用pthread_cond_broadcast来叫醒所有正在等待的线程。
代码如下：

//把时间到了，加token这个函数用一个线程来完成
static void* thr_alarm(void* p)
{
	......
    while(1)
    {
		.......
        job[i]->token = job[i]->burst;
        //下面这两句代码的顺序关系不大(除非是在非常特定情况下),都有道理.
        //比如解锁之前就发通知,可以先唤醒正在等待的进程,
        //让他们做好抢锁的准备（等这边一解锁之后,就立刻去抢锁）
        //这样就可以在有很多种线程都在抢锁的时候,他们抢到锁的机会更大些。

        //当然,也可以先解锁,因为加锁的目的是控制token的值,
        //而且临界区的代码要越少越好。

        //因为这里只有一种线程(只有多个同类型的令牌桶)在抢锁,所以我更倾向于先解锁,再发通知.
        pthread_mutex_unlock(&job[i]->mut_token);
        pthread_cond_broadcast(&job[i]->mytbf_cond);
    	......
    }
}

最后，还需要考虑的是更全面的一种情况。

假如说，我现在正在和别人共用同一个令牌桶。
比如，我们的目的是把A文件复制到B文件的位置，我的这一个流控能实现每秒钟复制10个字节，另外还有一个人干活，它可以实现每秒钟复制5个字节（我们协调操作同一个令牌桶），这样总共就是每秒钟能复制15个字节。

那这样的话，就有可能出现下面这种情况。
我针对这个令牌桶来取token，可是token被你提前一步给取走了。那我就会因为没有token而等待。

int mytbf_fetchtoken(mytbf_t* ptr, int size)
{
......
......
//查看我当前有没有token
//要加锁查看
pthread_mutex_lock(&mytbf->mut_token);
while(mytbf->token <= 0)
{
	pthread_cond_wait(&mytbf->cond,&mytbf->mut_token);//阻塞到这
	......

而你在使用完token后，发现取多了。就来返还token，也许返还回来的token就足够我使用了。所以当你返还回来之后，你就发消息来通知我一下。
从而在mytbf_returntoken中，我们加上这么一句代码。

int mytbf_returntoken(mytbf_t* ptr,int size)
{
    ......
    pthread_mutex_unlock(&mytbf->mut_token);
    pthread_cond_broadcast(&mytbf->cond);
 	......
}

总结：发通知就像过马路，当红灯变成绿灯，你就可以过马路了。
所以通知机制也一定要有监听(wait)。

xuechanba
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
限流的两个算法：令牌桶、漏桶算法
damicook的博客
03-22 434
常用的更平滑的限流算法有两种:漏桶算法和令牌桶算法. 1 漏桶算法 漏桶(Leaky Bucket)算法思路很简单,水(请求)先进入到漏桶里,漏桶以一定的速度出水(接口有响应速率),当水流入速度过大会直接溢出(访问频率超过接口响应速率),然后就拒绝请求,可以看出漏桶算法能强行限制数据的传输速率: 2.2令牌桶算法 令牌桶算法(Token Bucket)和 Leaky Bucke...
php使用lua+redis实现限流，计数器模式，令牌桶模式
10-17
本文将详细介绍如何利用PHP、Lua和Redis实现计数器模式和令牌桶模式的限流机制。 首先，我们来看计数器模式。计数器模式的核心是通过增加一个计数器来统计请求的数量，当计数超过预设阈值时，系统开始限制新的请求...
linux系统编程之信号（四）：alarm和可重入函数
diehuojiang5959的博客
07-15 192
一，alarm() 在将可重入函数之前我们先来了解下alarm()函数使用： #include <unistd.h> unsigned int alarm(unsigned int seconds) 系统调用alarm安排内核为调用进程在指定的seconds秒后发出一个SIGALRM的信号。如果指定的参数seconds为0，则不再发送 SIGALRM信号。后一次设定将...
Linux系统编程46 信号 - 流量控制，通过漏桶，令牌桶实现
奶牛养殖场小马
02-24 535
实验1： 漏桶实例，流量控制，每秒cat10个字符 输出到标准输出 signal + alarm + pause + 信号打断阻塞的系统调用 #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <errno.h> #
进程让他每隔5秒钟执行一次（非阻塞）
非淡泊无以明志，非宁静无以致远
10-16 4535
在Linux实现一个定时器，不像Win32下那样直观。在Win32调用SetTimer就行了，在Linux下则没有相应函数可以直接调用。定时器作为一个常用的功能，在Linux当然也有相应实现。下面我们看看几种常用的方法。     要实现定时器功能，最土的办法实现莫过于用sleep/usleep来实现了。当然，它会阻塞当前线程，除了处理定时功能外，什么活也干不了。当然要解决这个问题不难，创建一个
alarm信号、select、RTC定时器
花花世界
10-09 755
原型： int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);例一：timeval的结构如下： struct timeval{ long tv_sec；/*secons* long tv_usec;/*m
token-bucket-master_令牌桶_
10-03
令牌桶算法的仿真
php 基于redis使用令牌桶算法实现流量控制
02-23
系统在运行过程中，如遇上某些活动，访问的人数会在一瞬间内爆增，导致服务器瞬间压力飙升，使系统超...本文介绍php基于redis，使用令牌桶算法，实现访问流量的控制，提供完整算法说明及演示实例，方便大家学习使用。
基于令牌桶算法的Java限流实现
02-23
基于令牌桶算法的Java限流实现是指使用令牌桶算法来控制系统的流量，使得系统的流量不超过设定的阈值。该算法的核心思想是将流量看作是一种资源，每个请求都需要消耗一定数量的资源，而令牌桶中存储的资源数量是有限...
java实现令牌桶限流
09-11
限流是对某一时间窗口内的请求数进行限制，保持...常用的限流算法有令牌桶和和漏桶，而Google开源项目Guava中的RateLimiter使用的就是令牌桶控制算法。 在开发高并发系统时有三把利器用来保护系统：缓存、降级和限流
Linux多线程实现令牌桶流量控制
02-19
Linux多线程实现令牌桶流量控制,内有makefile
alarm发送信号
taifyang的博客
02-21 250
时钟信号 alarm 定时给自己发送SIGALRM unsigned int alarm(unsigned int seconds); seconds 几秒后发送信号 返回值，上次闹钟剩余的秒数 特别的，如果传入参数为0，代表取消闹钟 alarm.c #include <stdio.h> #include <unistd.h> int main(int argc,char * argv[]) { int ret=0; ret=alarm(6); printf
# linux c 广播流媒体文件（令牌桶）
a312024054的专栏
09-18 1592
源码:https://github.com/FzhangSpace/net_radio.git(一) 概要实现的功能,广播流媒体文件,发送端和接收端,发送端分为200个频道,其中有一个菜单频道,和其他的数据频道,接收端通过客户端通过菜单选择数据频道,并且通过mpg123播放 (二)模块划分发送端菜单发送模块: 负责发送菜单,包括频道号,以及该频道相应的描述,以供接收端选择频道媒体数据发送模块
多线程实现令牌桶算法（互斥量+条件变量）
qq_51931826的博客
05-17 503
多线程+互斥量+条件变量+封装成库函数
信号通信alarm
qq_43849025的博客
02-13 217
定时器的实现 #include"stdio.h" #include"sys/types.h" #include"signal.h" #include"stdlib.h" #include"unistd.h" int main() { int i; i=0; printf("alarm before\n"); alarm(9); printf("alarm after\n"); whil...
linux系统下alarm函数详解 信号处理函数signal
weixin_45019830的博客
05-18 1044
alarm()函数说明 1.引用头文件：#include <unistd.h>; 2.函数标准式：unsigned int alarm(unsigned int seconds); 3.功能与作用：alarm()函数的主要功能是设置信号传送闹钟，即用来设置信号SIGALRM在经过参数seconds秒数后发送给目前的进程。如果未设置信号SIGALARM的处理函数，那么alarm()默认处理终止进程。 4.函数返回值：如果在seconds秒内再次调用了alarm函数设置了新的闹钟，则后面定时器的设置
令牌桶算法——多线程实现
cprimesplus的博客
02-15 970
相关注意事项都写在了注释当中 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <signal.h> #include <unistd.h> #include <errno.h> #include <sys/time.h> #include <pthread.h> #include "mytbf.h" // typedef v
基于多 goroutine 实现令牌桶
weixin_33877092的博客
12-07 257
前言 令牌桶是一种常见用于控制速率的控流算法。原理于 Wikipedia 上描述如下： 每秒会有 r 个令牌被放入桶中，即每 1 / r 秒向桶中放入一个令牌。 一个桶最多可以存放 b 个令牌。当令牌被放入桶时，若桶已满，则令牌被直接丢弃。 当一个 n 字节的数据包抵达时，消耗 n 个令牌，然后放行之。 若桶中的令牌不足 n ，则该数据...
linux高编信号-------令牌桶实现
weixin_34356555的博客
03-22 139
main.c /********************************* *功能：每秒从文件读N个字节（N可控） *使用信号机制实现令牌桶:解决数据流不均匀传输 * *****************************/ #include <stdio.h> #include <stdlib.h> #include <sys...
NetMagic路由器设计：令牌桶原理与实现
为了提供良好的QoS，流量整形技术如漏桶和令牌桶被广泛使用。漏桶算法虽然简单，但无法应对突发流量，可能导致数据丢失或固定速率输出的限制。相比之下，令牌桶算法能够更好地适应流量的突发性，因为它允许在桶中有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xuechanba

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值