令牌桶算法——多线程实现

最新推荐文章于 2023-02-09 09:25:29 发布
最新推荐文章于 2023-02-09 09:25:29 发布
阅读量970 收藏 4
点赞数 1
分类专栏： Linux环境编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cprimesplus/article/details/113816349
版权

相关注意事项都写在了注释当中
【互斥锁版本】
注意，若不满足到对某资源进行操作的条件，则一直while循环，反复轮询“开锁——等待——加锁”的过程，会造成“忙等”的现象。解决方法是通过条件变量的方式。

#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 void (*sighandler_t)(int);

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

struct mytbf_st *job[MYTBF_MAX];
static pthread_t tid_alrm;
static pthread_once_t ini_once = PTHREAD_ONCE_INIT;
static pthread_mutex_t mut_job = PTHREAD_MUTEX_INITIALIZER;

// 命名中应该体现，此函数需要加锁才能使用 xxx_unlocked()
static int get_free_pos_unlocked(void)
{
    for(int i = 0; i < MYTBF_MAX; i++)
    {
        if(job[i] == NULL)
            return i;
    }
    return -1;
}

static void module_unload(void)
{
    pthread_cancel(tid_alrm);
    pthread_join(tid_alrm, NULL);
    for(int i = 0; i < MYTBF_MAX; i++)
    {
        if(job[i] != NULL)
        {
            mytbf_destroy(job[i]);
        }
    }
    pthread_mutex_destroy(&mut_job);
}

static void *thr_alrm(void *p)
{
    while(1)
    {
        for(int i = 0; i < MYTBF_MAX; i++) {
            pthread_mutex_lock(&mut_job);
            if(job[i] != NULL)
            {
                pthread_mutex_lock(&job[i]->mut);
                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);
            }
            pthread_mutex_unlock(&mut_job);
        }
        sleep(1);
    }

    // pthread_exit(NULL);
}

static void module_load(void)
{
    int err;
    err = pthread_create(&tid_alrm, NULL, thr_alrm, NULL);

    if(err)
    {
        fprintf(stderr, "pthread_create(): %s\n", strerror(errno));
        pthread_join(tid_alrm, NULL);
        exit(1);
    }

    // alrm_handler_save = signal(SIGALRM, alrm_handler);
    // alarm(1);   
    // setitimer(ITIMER_REAL, itm, NULL);
    
    // 因为thr_alrm线程一直在后台运行(while(1))，而pthread_join的作用是阻塞等待，故程序会一直卡在pthread_join处
    // 而不向后执行，因此这里不能使用pthread_join，而是在module_unload函数中使用cancel取消线程，接着join
    // pthread_join(tid_alrm, NULL);
    atexit(module_unload);
}

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

    me = (struct mytbf_st *)malloc(sizeof(struct mytbf_st));
    if(me == NULL) {
        return NULL;
    }
    me->cps = cps;
    me->burst = burst;
    me->token = 0;
    pthread_mutex_init(&me->mut, NULL);

    // 临界区内的跳转语句一定要记住归还锁的状态
    pthread_mutex_lock(&mut_job);
    pos = get_free_pos_unlocked();
    if(pos == -1) {
        pthread_mutex_unlock(&mut_job);
        free(me);
        return NULL;
    }

    me->pos = pos;

    job[pos] = me;
    pthread_mutex_unlock(&mut_job);
    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;
    
    // 取令牌时，若桶中为空，则等待桶中有令牌再取
    pthread_mutex_lock(&me->mut);
    while(me->token <= 0)
    {
        pthread_mutex_unlock(&me->mut);
        sched_yield();
        pthread_mutex_lock(&me->mut);
    }

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

    me->token -= n;
    pthread_mutex_unlock(&me->mut);
    return n;
}

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

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

    pthread_mutex_lock(&me->mut);
    me->token += size;

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

    return size;
}

int mytbf_destroy(mytbf_t *ptr)
{
    struct mytbf_st *me = ptr;

    pthread_mutex_lock(&mut_job);
    job[me->pos] = NULL;
    pthread_mutex_unlock(&mut_job);
    
    pthread_mutex_destroy(&me->mut);
    free(me);
    return 0;
}

【条件变量版本】

#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 void (*sighandler_t)(int);

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

struct mytbf_st *job[MYTBF_MAX];
static pthread_t tid_alrm;
static pthread_once_t ini_once = PTHREAD_ONCE_INIT;
static pthread_mutex_t mut_job = PTHREAD_MUTEX_INITIALIZER;

// 命名中应该体现，此函数需要加锁才能使用 xxx_unlocked()
static int get_free_pos_unlocked(void)
{
    for(int i = 0; i < MYTBF_MAX; i++)
    {
        if(job[i] == NULL)
            return i;
    }
    return -1;
}

static void module_unload(void)
{
    pthread_cancel(tid_alrm);
    pthread_join(tid_alrm, NULL);
    for(int i = 0; i < MYTBF_MAX; i++)
    {
        if(job[i] != NULL)
        {
            mytbf_destroy(job[i]);
        }
    }
    pthread_mutex_destroy(&mut_job);
}

static void *thr_alrm(void *p)
{
    while(1)
    {
        for(int i = 0; i < MYTBF_MAX; i++) {
            pthread_mutex_lock(&mut_job);
            if(job[i] != NULL)
            {
                pthread_mutex_lock(&job[i]->mut);
                job[i]->token += job[i]->cps;
                if(job[i]->token > job[i]->burst)
                    job[i]->token = job[i]->burst;
                
                // 十个令牌桶都在等token，如果使用signal，则只是唤醒其中一个（具体哪个不知道）
                // 假设当前刚给0号令牌桶加完token，使用signal可能唤醒的是第7号令牌桶，显然不对。因此要broadcast广播
                // broadcast不可避免的引起了惊群效应
                pthread_cond_broadcast(&job[i]->cond);
                pthread_mutex_unlock(&job[i]->mut);
            }
            pthread_mutex_unlock(&mut_job);
        }
        sleep(1);
    }

    // pthread_exit(NULL);
}

static void module_load(void)
{
    int err;
    err = pthread_create(&tid_alrm, NULL, thr_alrm, NULL);

    if(err)
    {
        fprintf(stderr, "pthread_create(): %s\n", strerror(errno));
        pthread_join(tid_alrm, NULL);
        exit(1);
    }
    
    // 因为thr_alrm线程一直在后台运行(while(1))，而pthread_join的作用是阻塞等待，故程序会一直卡在pthread_join处
    // 而不向后执行，因此这里不能使用pthread_join，而是在module_unload函数中使用cancel取消线程，接着join
    // pthread_join(tid_alrm, NULL);
    atexit(module_unload);
}

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

    me = (struct mytbf_st *)malloc(sizeof(struct mytbf_st));
    if(me == NULL) {
        return NULL;
    }
    me->cps = cps;
    me->burst = burst;
    me->token = 0;
    pthread_mutex_init(&me->mut, NULL);
    pthread_cond_init(&me->cond, NULL);

    // 临界区内的跳转语句一定要记住归还锁的状态
    pthread_mutex_lock(&mut_job);
    pos = get_free_pos_unlocked();
    if(pos == -1) {
        pthread_mutex_unlock(&mut_job);
        free(me);
        return NULL;
    }

    me->pos = pos;

    job[pos] = me;
    pthread_mutex_unlock(&mut_job);
    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;
    
    // 取令牌时，若桶中为空，则等待桶中有令牌再取
    pthread_mutex_lock(&me->mut);
    while(me->token <= 0)
    {
        // 发现条件成立，解锁等待，直到收到broadcast或者signal的通知，然后抢(加)锁。若未抢到则继续阻塞。
        // 条件变量对应通知机制，对比于查询机制，可以不用忙等，而是阻塞等待
        pthread_cond_wait(&me->cond, &me->mut);
        // pthread_mutex_unlock(&me->mut);
        // sched_yield();
        // pthread_mutex_lock(&me->mut);
    }

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

    me->token -= n;
    pthread_mutex_unlock(&me->mut);
    return n;
}

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

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

    pthread_mutex_lock(&me->mut);
    me->token += size;

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

    return size;
}

int mytbf_destroy(mytbf_t *ptr)
{
    struct mytbf_st *me = ptr;

    pthread_mutex_lock(&mut_job);
    job[me->pos] = NULL;
    pthread_mutex_unlock(&mut_job);
    
    pthread_mutex_destroy(&me->mut);
    pthread_cond_destroy(&me->cond);
    free(me);
    return 0;
}
摩霄志在潜修羽
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
线程实现令牌桶(封装成库函数)
qq_51931826的博客
05-17 578
多线程编程实现令牌桶算法
Linux多线程实现令牌桶流量控制
02-19
Linux多线程实现令牌桶流量控制,内有makefile
多线程实现令牌桶算法（互斥量+条件变量）
qq_51931826的博客
05-17 503
多线程+互斥量+条件变量+封装成库函数
令牌桶算法c实现
11-29
Token Bucket Emulation in C using Multithreading This project involved emulation of the Token Bucket algorithm using POSIX threads in C. The aim was to simulate a traffic shaper that receives and transmits packets to a server, while being controlled by a token bucket filter. There were three major components of the system : 1. The input queue that received the packets 2. The token bucket that received the tokens 3. The output queue that send the packets to the server
线程令牌
weixin_30578677的博客
08-06 219
　　最近在项目中碰到一个很头疼的问题，在前端连接事件中写了一个广播线程，该广播线程写在while循环中，但是前台会有很多个客户端，没连接一次就会有一个广播线程开启，很吃资源，刚开始我解决这个问题的方法是每次触发连接事件是检测一下当前连接数，如果是count_client<=1,就开线程，否则跳过广播，但这个方法只适用于连接事件中判断，如果我是在接收事件中，根据接收结果开启广播线程，那么就无法...
用C语言写一个令牌桶算法
weixin_42611177的博客
02-09 174
我可以给你一个参考： #include <stdio.h> int main() { int tokens; // 当前令牌数 int rate; // 每秒添加令牌的速率 int capacity; // 令牌桶容量 int time; // 请求令牌的时间 // 初始化令牌桶 tokens = 0; rate = 1; capacity = 10; ...
基于令牌桶算法的Java限流实现
02-23
在Java中，我们可以使用synchronized关键字来实现线程安全的令牌桶算法。具体来说，我们可以使用volatile关键字来标记令牌桶中的资源数量，并使用CAS操作来实现资源的减少和增加操作。同时，我们还可以使用wait和...
基于令牌桶算法实现的SpringBoot无锁限流插件
08-07
在本文中，我们将详细探讨如何利用令牌桶算法实现一个SpringBoot无锁限流插件，以及其在Java Web开发中的应用。 首先，SpringBoot作为一款轻量级的Java Web框架，因其简洁的配置和强大的功能深受开发者喜爱。结合...
人工智能-项目实践-多线程-Paxos算法的多线程实现.zip
最新发布
01-04
总的来说，Paxos算法的多线程实现是将分布式一致性理论与实际编程技术结合的体现，它需要深入理解Paxos算法的工作原理以及Java多线程机制，以构建出高效且稳定的分布式系统。在这个过程中，还需要考虑性能优化、容错...
iOS高级程序员进阶——多线程编程核心技术模式篇
06-18
多线程是一种软件实现多个线程并发执行任务的技术。在iOS开发中，实现多线程的的方式有很多种，常用的有pthread、NSThread、GCD与NSOperation。在实际应用中，多线程技术也有着非常多的使用场景，比如异步的网络请求...
c语言linklist及各种功能并实现token令牌仿真
07-13
这是一门操作系统课程的作业 c语言实现linkedlist插入，删除，追加节点，等等功能，并仿真计算机里的令牌机制
令牌桶简单实现（Java）
xxxxssss12的博客
07-15 5362
令牌桶简单实现（Java） 文章目录令牌桶简单实现（Java）简介实现思路codemain输出结果 简介 百度可得，令牌桶是一个桶，定时往里面放令牌，然后请求来了从令牌桶里取令牌，取到了继续后续逻辑，没取到就拦截不让请求，达到限流目的 实现思路 参考了guava的RateLimiter之后，发现并没有“一个线程定时往桶里放token”，而是在请求进来时通过当前时间戳实时计算（下一次加令牌的时间为x，此时时间为m，平均n秒放一个令牌，则此时应当增加 (m - x) / n + 1 个令牌） code /**
基于多 goroutine 实现令牌桶
weixin_33877092的博客
12-07 257
前言 令牌桶是一种常见用于控制速率的控流算法。原理于 Wikipedia 上描述如下： 每秒会有 r 个令牌被放入桶中，即每 1 / r 秒向桶中放入一个令牌。 一个桶最多可以存放 b 个令牌。当令牌被放入桶时，若桶已满，则令牌被直接丢弃。 当一个 n 字节的数据包抵达时，消耗 n 个令牌，然后放行之。 若桶中的令牌不足 n ，则该数据...
令牌桶算法——信号量实现
cprimesplus的博客
02-05 460
头文件定义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
令牌桶 -- alarm信号、漏桶、alarm信号实现的令牌桶、使用alarm信号将令牌桶封装成库、互斥量重新实现令牌桶、使用条件变量修改并实现令牌桶
xuechanba的博客
08-25 522
alarm() 一个信号从发出到收到，有一个不可避免的时延。所以如果使用信号来计时的话,10ms以内的计时不准确。只要超过这个时间，基本上都能准确的用信号来计时。 alarm没有办法直接实现多任务的计时器，因为当程序中有多个alarm时，程序计时可能就会以最后一个alarm为准，所以alarm不能直接用于多任务的计时器。因此，我们需要思考怎么使用alarm这样一个单一的计时器来实现10秒做一个事，5秒做一个事，1秒做一个事的多任务计时器。 pause() NAME pause - wait f
限流的两个算法：令牌桶、漏桶算法
damicook的博客
03-22 434
常用的更平滑的限流算法有两种:漏桶算法和令牌桶算法. 1 漏桶算法 漏桶(Leaky Bucket)算法思路很简单,水(请求)先进入到漏桶里,漏桶以一定的速度出水(接口有响应速率),当水流入速度过大会直接溢出(访问频率超过接口响应速率),然后就拒绝请求,可以看出漏桶算法能强行限制数据的传输速率: 2.2令牌桶算法 令牌桶算法(Token Bucket)和 Leaky Bucke...
c++ 分布式令牌桶_分布式之流量控制
weixin_31787839的博客
01-12 450
最近在做数据对外服务的功能，涉及到针对某个用户或者某个API的流量控制。说到流量控制，最常想到就是平时使用的带宽限速，实现起来也有几种常见的方法：消息队列、漏斗策略和令牌桶算法。方法1：消息队列为了实现流量控制，可以在服务端处理前先保存到消息队列中，服务器再慢慢消费。不过这种方案请求都放在一个消息队列中，可能会造成消费不及时，客户端访问超时，所以比较适合不需要快速响应的场景。方法2：漏斗...
算法设计（贪婪算法、漏桶算法、令牌桶算法、计数器）
07-31 647
一、贪心算法 也叫贪婪算法，是指在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，它所做出的仅仅是在某种意义上的局部最优解，最终通过各环节局部最优解促成整体的最优解。 贪心算法没有固定的算法框架，算法设计的关键是贪心策略的选择。 必须注意的是，贪心算法不是对所有问题都能得到整体最优解，选择的贪心策略必须具备无后效性（即某个状态以后的过程不会影响以前的状态，只与当前状态有关。）所以，对所采用的贪心策略一定要仔细分析其是否满足无后效性。 1.1贪心算法的基本思路 ..
令牌桶算法实现收集
路漫漫其修远兮
11-29 2053
http://www-scf.usc.edu/~trigunay/token-bucket.html
java的令牌桶算法实现
03-31
令牌桶算法是一种流量控制算法，可以用于限制某个接口或服务的访问频率。下面是一种简单的Java实现： ```java import java.util.concurrent.atomic.AtomicLong; public class TokenBucket { private final AtomicLong tokens; // 当前可用的令牌数 private final int capacity; // 令牌桶的容量 private final long refillInterval; // 令牌填充的时间间隔 private final long refillAmount; // 每次填充的令牌数 private volatile long lastRefillTime; // 上次填充令牌的时间 public TokenBucket(int capacity, long refillInterval, long refillAmount) { tokens = new AtomicLong(capacity); this.capacity = capacity; this.refillInterval = refillInterval; this.refillAmount = refillAmount; lastRefillTime = System.currentTimeMillis(); } // 尝试获取令牌，成功返回true，失败返回false public boolean tryAcquire() { refill(); return tokens.getAndUpdate(n -> n > 0 ? n - 1 : 0) > 0; } // 填充令牌 private void refill() { long now = System.currentTimeMillis(); long elapsedTime = now - lastRefillTime; if (elapsedTime > refillInterval) { long newTokens = elapsedTime / refillInterval * refillAmount; lastRefillTime += elapsedTime / refillInterval * refillInterval; tokens.updateAndGet(n -> Math.min(capacity, n + newTokens)); } } } ``` 在上述实现中，TokenBucket类的构造函数需要传入令牌桶的容量、令牌填充的时间间隔以及每次填充的令牌数。tryAcquire方法用于尝试获取一个令牌，如果当前可用令牌数大于0，则将可用令牌数减1并返回true，否则直接返回false。refill方法用于填充令牌，如果当前时间距离上次填充令牌的时间超过了填充间隔，则计算应该填充的令牌数，并更新可用令牌数。注意，在更新可用令牌数时，需要使用AtomicLong类来保证线程安全。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值