令牌桶算法——信号量实现

最新推荐文章于 2024-07-17 23:19:15 发布
最新推荐文章于 2024-07-17 23:19:15 发布
阅读量466 收藏 3
点赞数
分类专栏： Linux环境编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cprimesplus/article/details/113701515
版权

头文件定义mytbf.h

#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_destroy(mytbf_t *);

#endif

令牌桶算法实现部分mytbf.c

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

#include "mytbf.h"
typedef void (*sighandler_t)(int);

struct mytbf_st
{
    int cps;    // 每秒传输
    int burst;  // 最大限制
    int token;  // 积累传输量
    int pos;    // 记录当前令牌桶在令牌桶数组中的下标
};

struct mytbf_st *mytbf_arr[MYTBF_MAX];
static int inited = 0;
static sighandler_t alrm_handler_save;

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

static void alrm_handler(int s)
{
    alarm(1);

    for(int i = 0; i < MYTBF_MAX; i++) {
        if(mytbf_arr[i] != NULL)
        {
            mytbf_arr[i]->token += mytbf_arr[i]->cps;
            if(mytbf_arr[i]->token > mytbf_arr[i]->burst)
                mytbf_arr[i]->token = mytbf_arr[i]->burst;
        }
    }
}

static void module_unload(void)
{
    signal(SIGALRM, alrm_handler_save);
    alarm(0);
    for(int i = 0; i < MYTBF_MAX; i++)
        free(mytbf_arr[i]);
}

static void module_load(void)
{
    alrm_handler_save = signal(SIGALRM, alrm_handler);
    alarm(1);   
    atexit(module_unload);
}

mytbf_t *mytbf_init(int cps, int burst)
{
    // 在init函数中使用alarm来定时，同时也要考虑到一个程序中可能创建不止一个令牌桶，如果第二个令牌桶也
    // 调用init，那么会出现两次alarm，程序也会因此执行出错。故应该将alarm设置为只在首次调用时使用。
    if(!inited) {
        module_load();
        inited = 1;
    }


    struct mytbf_st *me = (struct mytbf_st *)malloc(sizeof(struct mytbf_st));
    if(me == NULL) {
        return NULL;
    }
    int pos = get_pos();
    if(pos == -1) {
        return NULL;
    }
    me->cps = cps;
    me->burst = burst;
    me->token = 0;
    me->pos = pos;

    mytbf_arr[pos] = me;

    return me;
}

static int min(const int a, const int b)
{
    return a < b ? a : b;
}

int mytbf_fetchtoken(mytbf_t *ptr, int size)
{
    struct mytbf_st *me = ptr;
    if(size <= 0)
        return -EINVAL;
    
    // 取令牌时，若桶中为空，则等待桶中有令牌再取
    while(me->token <= 0)
        pause();

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

int mytbf_returntoken(mytbf_t *ptr, int size)
{
    struct mytbf_st *me;

    if(size <= 0) {
        return -EINVAL;
    }

    me->token += size;

    // 令牌桶满则丢弃溢出的部分
    if(me->token > me->burst) {
        me->token = me->burst;
    }

    return size;
}

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

【注】
使用alarm(N)实现令牌桶或者漏桶时，需要构造“alarm链”，也就是说本次的alarm计时结束并发出SIGALRM信号后，经由singal(SIGALRM, func)捕捉，同时func函数应该设置下一次alarm(N)来继续循环计时。
若将alarm替换为seitimer()函数，就无需再设置下一次alarm，因为seitimer的参数为itimerval类型的指针，这个类型中包括新旧时间，当旧时间结束后，新时间会自动copy给旧时间，达到自动进入下一次计时的目的。
另外，将新时间复制给旧时间的操作是不可分割的原子操作。seitimer计时结果相比alarm更加精准。

seitimer设置执行时间：

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

#include "mytbf.h"
typedef void (*sighandler_t)(int);

struct mytbf_st
{
    int cps;    // 每秒传输
    int burst;  // 最大限制
    int token;  // 积累传输量
    int pos;    // 记录当前令牌桶在令牌桶数组中的下标
};

struct mytbf_st *mytbf_arr[MYTBF_MAX];
static int inited = 0;
static sighandler_t alrm_handler_save;

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

static void alrm_handler(int s)
{
    // alarm(1);

    for(int i = 0; i < MYTBF_MAX; i++) {
        if(mytbf_arr[i] != NULL)
        {
            mytbf_arr[i]->token += mytbf_arr[i]->cps;
            if(mytbf_arr[i]->token > mytbf_arr[i]->burst)
                mytbf_arr[i]->token = mytbf_arr[i]->burst;
        }
    }
    // alarm(1);

}

static void module_unload(void)
{
    signal(SIGALRM, alrm_handler_save);
    // alarm(0);
    for(int i = 0; i < MYTBF_MAX; i++)
        free(mytbf_arr[i]);
}

static void module_load(void)
{
    struct itimerval *itm = (struct itimerval *)malloc(sizeof(struct itimerval));
    itm->it_interval.tv_sec = 1;
    itm->it_interval.tv_usec = 0;
    itm->it_value.tv_sec = 1;
    itm->it_value.tv_usec = 0;

    alrm_handler_save = signal(SIGALRM, alrm_handler);
    // alarm(1);   
    setitimer(ITIMER_REAL, itm, NULL);
    atexit(module_unload);
}

mytbf_t *mytbf_init(int cps, int burst)
{
    // 在init函数中使用alarm来定时，同时也要考虑到一个程序中可能创建不止一个令牌桶，如果第二个令牌桶也
    // 调用init，那么会出现两次alarm，程序也会因此执行出错。故应该将alarm设置为只在首次调用时使用。
    if(!inited) {
        module_load();
        inited = 1;
    }


    struct mytbf_st *me = (struct mytbf_st *)malloc(sizeof(struct mytbf_st));
    if(me == NULL) {
        return NULL;
    }
    int pos = get_pos();
    if(pos == -1) {
        return NULL;
    }
    me->cps = cps;
    me->burst = burst;
    me->token = 0;
    me->pos = pos;

    mytbf_arr[pos] = me;

    return me;
}

static int min(const int a, const int b)
{
    return a < b ? a : b;
}

int mytbf_fetchtoken(mytbf_t *ptr, int size)
{
    struct mytbf_st *me = ptr;
    if(size <= 0)
        return -EINVAL;
    
    // 取令牌时，若桶中为空，则等待桶中有令牌再取
    while(me->token <= 0)
        pause();

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

int mytbf_returntoken(mytbf_t *ptr, int size)
{
    struct mytbf_st *me;

    if(size <= 0) {
        return -EINVAL;
    }

    me->token += size;

    // 令牌桶满则丢弃溢出的部分
    if(me->token > me->burst) {
        me->token = me->burst;
    }

    return size;
}

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

测试（模拟cat命令，令牌桶控制流量）

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "mytbf.h"
#include "mytbf.c"
#define BUFF_SIZE   10
#define BURST       100
#define SOURCE_FILE "such_file"

static int sc_fd, dest_fd;

int main() 
{
    struct mytbf_st *tbf = mytbf_init(BUFF_SIZE, BURST);
    if(tbf == NULL) {
        fprintf(stderr, "mytbf_init():init failed.\n");
        exit(1);
    }

    int size = 0;
    char buff[BUFF_SIZE];
    do {
        if((sc_fd = open(SOURCE_FILE, O_RDONLY)) < 0) {
            if(errno != EINTR) {
                perror("open()");
                exit(1);                 
            }
        }
    } while(sc_fd < 0);

    // open successfully
    while(1) {
        size = mytbf_fetchtoken(tbf, BUFF_SIZE);
        if(size < 0) {
            fprintf(stderr, "mytbf_fetchtoken() failed: %s\n", strerror(-size));
            exit(1);
        }
        
        int read_ret, write_ret;
        // 频繁被中断打断，例如打断了5秒，那么令牌桶中就积累了me->token+5*CPS的令牌，当成功执行后，可以将
        // 上述令牌个数的字节全数输出
        while((read_ret = read(sc_fd, buff, size)) < 0) {
            if(errno != EINTR) {
                perror("read()");
                break;
            }
        }
        if(read_ret == 0) {
            break;
        }

        if(size - read_ret > 0)
            mytbf_returntoken(tbf, size-read_ret);

        int mark = read_ret;
        while(mark) {
            write_ret = write(1, buff, mark);
            mark -= write_ret;
            if(write_ret < 0) {
                if(errno != EINTR) {
                    perror("write()");
                    exit(1);
                }
                //else continue;
            }
            
            //signal(SIGABRT, func);
        }
    }

    close(sc_fd);
    close(dest_fd);
    exit(0);
}
摩霄志在潜修羽
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
快速傅里叶算法——基于C语言实现
12-02
快速傅里叶变换（FFT）是一种高效的计算离散傅里叶变换（DFT）的算法，对于信号处理、图像分析、通信工程等多个IT领域都至关重要。C语言由于其高效、简洁的特点，常被用于实现这样的底层算法。在这个压缩包中，包含...
令牌桶C语言代码实现
colortztzztzt的博客
08-23 293
cps 每秒钟传输字节数burst 令牌桶内最多能传输的字节数，token的最大值token 令牌的个数之前是一个令牌(token)对应一个字节，现在将一个token变为一个cps，cps是解码速率，每攒到一个令牌，就token+=cps如果需要不同的速率，使用不同的令牌桶，将令牌桶存储在一个数组中。
令牌桶算法理解学习（限流算法）
nimo观察者
12-10 1423
在r=10，b=5时，即表明每1/r=0.1，每0.1秒投入一个令牌，而在到0.5秒时达到桶的极限容量5，在此刻继续投入令牌则无法维持，这些令牌将会被废弃，同时在此时若有5个指令同时想要去走令牌则可以同时取走令牌桶内的所有令牌，即为取走b=5个。令牌桶算法是网络流量整形（Traffic Shaping）和速率限制（Rate Limiting）中最常使用的一种算法。典型情况下，令牌桶算法用来控制发送到网络上的数据的数目，并允许突发数据的发送。
令牌桶｜Web服务中的令牌桶设计和实现
最新发布
weixin_44435110的博客
07-17 695
令牌桶（Token Bucket）是一种用于流量控制的算法，在网络通信、API限流、带宽管理等场景中广泛应用。通过控制令牌的生成和消费速率，可以有效防止服务器过载，保证系统的稳定性和可用性。通过以上设计和实现步骤，我们构建了一个基于令牌桶算法的API限流方案。该方案使用Redis存储令牌桶状态，支持分布式环境，能够有效控制API请求频率，防止服务器过载，提高系统的稳定性和可用性。
令牌桶算法的实现
2301_81922209的博客
12-30 530
限流，令牌桶算法的实现
用C语言写一个令牌桶算法
weixin_42611177的博客
02-09 184
我可以给你一个参考： #include <stdio.h> int main() { int tokens; // 当前令牌数 int rate; // 每秒添加令牌的速率 int capacity; // 令牌桶容量 int time; // 请求令牌的时间 // 初始化令牌桶 tokens = 0; rate = 1; capacity = 10; ...
限速linux c语言,基于Linux系统的流量控制程序的C语言代码
weixin_34434843的博客
05-14 344
基于Linux系统的流量控制程序的C语言代码基于Linux系统的流量控制程序的C语言代码mytbf.h头文件ifndef MYTBF_H_#define MYTBF_H_typedef void mytbf_t;mytbf_t *tbf_init(int bits,int max);int gettoken(mytbf_t *tbf,int tknum);int returntoken(mytbf...
RR.zip_时间片轮转算法的实现——Qt
09-14
在本文中，我们将深入探讨时间片轮转算法的原理、优势以及如何在Qt环境中实现这一算法。 时间片轮转算法的核心思想是将处理器时间划分为一系列固定长度的时间片，每个时间片通常为几十毫秒。系统会按照一定的顺序...
进程同步——信号量机制
04-20
关于信号量的文章，生产者消费者问题与读者写者问题---信号量机制，PV操作——进程同步的信号量问题，利用信号机制实现的 父子进程同步，嵌入式linux的学习笔记-进程间通信的信号与信号集(四)1）进程的同步与互斥 ...
DOA估计算法——ESPRIT算法
08-18
**DOA估计算法——ESPRIT算法详解** 在无线通信和雷达系统中，DOA（Direction of Arrival）估计是一项关键技术，它用于确定信号源相对于接收阵列的方向。DOA估计算法有很多种，其中ESPRIT（Estimation of Signal ...
ucos-ii学习笔记——信号量的原理及使用
04-22
ucos-ii学习笔记——信号量的原理及使用 ucOS-II 是一个开源的实时操作系统，广泛应用于嵌入式系统中。信号量是ucOS-II中的一种同步机制，用于多任务之间的同步和互斥访问共享资源。下面是对ucOS-II中信号量的原理...
基于RateLimiter的令牌桶算法实现限速控制和计算法实现限流控制
08-01
本demo适用于分布式环境的基于RateLimiter令牌桶算法的限速控制与基于计数器算法的限量控制，可应用于中小型项目中有相关需求的场景（注：本实现未做压力测试，如果用户并发量较大需验证效果）。
基于Linux系统的流量控制程序的C语言代码
风翼随心的博客
08-11 1368
基于Linux系统的流量控制程序的C语言代码 mytbf.h头文件 ifndef MYTBF_H_ #define MYTBF_H_ typedef void mytbf_t; mytbf_t *tbf_init(int bits,int max); int gettoken(mytbf_t *tbf,int tknum); int returntoken(mytbf_t *tbf,i...
令牌桶算法——多线程实现
cprimesplus的博客
02-15 976
相关注意事项都写在了注释当中 #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
TBF(Trajectory Based Forwarding)路由协议
糖糖的daddy
08-24 863
TBF路由协议是一种基于源站和位置的路由协议，和GPSR路由协议一样需要GPS定位系统或其他方法协助确定节点的位置，可以利用GPSR路由协议中阐述的方法来绕开“路由空洞”。    与GPSR不同处是TBF协议的数据传递不是沿着最短路径而是通过指定一条连续的传递路径;数据包头的路由信息大小基本固定，拓扑发生变化和网络的规模不会影响其开销，弥补了传统源站路由协议的不足。网络节点根据贪婪算法中的轨道参数
linux高编信号-------令牌桶实现
weixin_34356555的博客
03-22 143
main.c /********************************* *功能：每秒从文件读N个字节（N可控） *使用信号机制实现令牌桶:解决数据流不均匀传输 * *****************************/ #include <stdio.h> #include <stdlib.h> #include <sys...
漏桶算法和令牌桶算法
天真吖的博客
04-14 803
这意味，面对瞬时大流量，该算法可以在短时间内请求拿到大量令牌，可以处理瞬时流量，而且拿令牌的过程并不是消耗很大的事情。算法思路简单，水（请求）先进入到漏桶中，漏桶以一定的速度出水（接口有响应速率），当水流速度过大直接溢出（访问频率超过接口响应频率），然后就拒绝请求，可以看出漏桶算法能强制限制数据的传输速率。令牌桶算法的原理是系统会以一个恒定的速度往桶里放入令牌，而如果请求需要被处理，则需要先从桶里获取一个令牌，当桶里没有令牌可取时，则拒绝服务。桶中请求数有限制，满了则丢弃，桶以一定速度处理请求。
令牌桶（Token Bucket）算法
大连赵哥的博客
04-26 1036
令牌桶（Token Bucket）算法
限流 -- 令牌桶算法
白羊座的橙子
12-26 1421
一、什么是令牌桶算法？三、单个Jvm应用的限流框架四、分布式的限流框架令牌桶算法是一种流量控制策略，用于限制请求数。它通过维护一个固定容量的“令牌桶”，并以恒定速率向其中添加令牌。当请求到达时，需要从桶中取出一个令牌才能被处理；如果没有可用的令牌，则请求将被拒绝或等待。
你可以用verilog实现令牌桶算法吗
05-18
是的，可以使用Verilog实现令牌桶算法。令牌桶算法是一种流量控制算法，它可以限制数据包从一个接口发送到另一个接口的速率。实现令牌桶算法的主要思路是使用一个计数器来表示当前可用的令牌数，每当一个数据包到达...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值