麻烦了解这个速率限制器如何工作

Question

我一直在试图为我的应用程序做一个速率限制器，并且遇到了这个代码。阅读完它后，我仍然无法理解它究竟发生了什么。

我目前的理解：

1）SetSmallRateLimit和SetLongRateLimit被调用初始化通道和开始运行的够程的处理器。

2）当调用requestAndUnmarshal时，checkRateLimiter发送一个信号给队列通道。

我不明白：

1）RateLimitHandler睡time.After（pertime）的持续时间，之后清除队列通道。不确定triggerWatcher和returnChan在做什么。

2）checkTimeTrigger - 不明白这个函数正在做什么或它的目的。

var (
    smallRateChan rateChan 
    longRateChan rateChan 
) 

type rateChan struct { 
    RateQueue chan bool 
    TriggerChan chan bool 
} 

//10 requests every 10 seconds 
func SetSmallRateLimit(numrequests int, pertime time.Duration) { 
    smallRateChan = rateChan{ 
     RateQueue: make(chan bool, numrequests), 
     TriggerChan: make(chan bool), 
    } 
    go rateLimitHandler(smallRateChan, pertime) 
} 

//500 requests every 10 minutes 
func SetLongRateLimit(numrequests int, pertime time.Duration) { 
    longRateChan = rateChan{ 
     RateQueue: make(chan bool, numrequests), 
     TriggerChan: make(chan bool), 
    } 
    go rateLimitHandler(longRateChan, pertime) 
} 

func rateLimitHandler(RateChan rateChan, pertime time.Duration) { 
    returnChan := make(chan bool) 
    go timeTriggerWatcher(RateChan.TriggerChan, returnChan) 
    for { 
     <-returnChan 
     <-time.After(pertime) 
     go timeTriggerWatcher(RateChan.TriggerChan, returnChan) 
     length := len(RateChan.RateQueue) 
     for i := 0; i < length; i++ { 
      <-RateChan.RateQueue 
     } 
    } 
} 

func timeTriggerWatcher(timeTrigger chan bool, returnChan chan bool) { 
    timeTrigger <- true 
    returnChan <- true 
} 

func requestAndUnmarshal(requestURL string, v interface{}) (err error) { 
    checkRateLimiter(smallRateChan) 
    checkRateLimiter(longRateChan) 
    resp, err := http.Get(requestURL) 
    defer resp.Body.Close() 
    if err != nil { 
     return 
    } 
    checkTimeTrigger(smallRateChan) 
    checkTimeTrigger(longRateChan) 
    if resp.StatusCode != http.StatusOK { 
     return RiotError{StatusCode: resp.StatusCode} 
    } 

    body, err := ioutil.ReadAll(resp.Body) 
    if err != nil { 
     return 
    } 

    err = json.Unmarshal(body, v) 
    if err != nil { 
     return 
    } 
    return 
} 

func checkRateLimiter(RateChan rateChan) { 
    if RateChan.RateQueue != nil && RateChan.TriggerChan != nil { 
     RateChan.RateQueue <- true 
    } 
} 

func checkTimeTrigger(RateChan rateChan) { 
    if RateChan.RateQueue != nil && RateChan.TriggerChan != nil { 
     select { 
     case <-RateChan.TriggerChan: 
     default: 
     } 
    } 
} 

Answer 1

我不认为你应该使用这段代码来学习任何有用的东西。 我不确定但它似乎试图限制请求率，但它是错误的。它允许进行一定数量的请求，然后等待一段时间。时间间隔后，它允许您再次发出请求。所有这些都是以非常复杂的方式完成的。

但它会导致很奇怪的情况。假设你做1req/h，你的限制是500req/20sec。然后，这段代码会导致您在500小时后等待20秒，并允许再次发出请求。

checkTimeTrigger从RateChan.TriggerChan中删除一条消息，如果它有任何消息，并且没有任何消息，并且它没有立即返回。

此代码显然不是DRY。更好的使用https://godoc.org/golang.org/x/time/rate是你想限制你的请求率。