golang服务器开发频率限制 golang.org/x/time/rate 使用说明

官方链接

接口介绍

type Limiter

type Limiter struct {
    // contains filtered or unexported fields
}

Limter限制时间的发生频率,采用令牌池的算法实现。这个池子一开始容量为b,装满b个令牌,然后每秒往里面填充r个令牌。
由于令牌池中最多有b个令牌,所以一次最多只能允许b个事件发生,一个事件花费掉一个令牌。

Limter提供三中主要的函数 Allow, Reserve, and Wait. 大部分时候使用Wait。

func NewLimiter

func NewLimiter(r Limit, b int) *Limiter

NewLimiter 返回一个新的Limiter。

func (*Limiter) [Allow]

func (lim *Limiter) Allow() bool

Allow 是函数 AllowN(time.Now(), 1)的简化函数。

func (*Limiter) AllowN

func (lim *Limiter) AllowN(now time.Time, n int) bool

AllowN标识在时间now的时候,n个事件是否可以同时发生(也意思就是now的时候是否可以从令牌池中取n个令牌)。如果你需要在事件超出频率的时候丢弃或跳过事件,就使用AllowN,否则使用Reserve或Wait.

func (*Limiter) Reserve

func (lim *Limiter) Reserve() *Reservation

Reserve是ReserveN(time.Now(), 1).的简化形式。

func (*Limiter) ReserveN

func (lim *Limiter) ReserveN(now time.Time, n int) *Reservation

ReserveN 返回对象Reservation ,标识调用者需要等多久才能等到n个事件发生(意思就是等多久令牌池中至少含有n个令牌)。

如果ReserveN 传入的n大于令牌池的容量b,那么返回false.
使用样例如下:

r := lim.ReserveN(time.Now(), 1)
if !r.OK() {
  // Not allowed to act! Did you remember to set lim.burst to be > 0 ?我只要1个事件发生仍然返回false,是不是b设置为了0?
  return
}
time.Sleep(r.Delay())
Act()

如果希望根据频率限制等待和降低事件发生的速度而不丢掉事件,就使用这个方法。
我认为这里要表达的意思就是如果事件发生的频率是可以由调用者控制的话,可以用ReserveN 来控制事件发生的速度而不丢掉事件。如果要使用context的截止日期或cancel方法的话,使用WaitN。

func (*Limiter) Wait

func (lim *Limiter) Wait(ctx context.Context) (err error)

Wait是WaitN(ctx, 1)的简化形式。

func (*Limiter) WaitN

func (lim *Limiter) WaitN(ctx context.Context, n int) (err error)

WaitN 阻塞当前直到lim允许n个事件的发生。

  • 如果n超过了令牌池的容量大小则报错。
  • 如果Context被取消了则报错。
  • 如果lim的等待时间超过了Context的超时时间则报错。

样例

测试 AllowN

package main

import (
   "os"
   "time"

   "golang.org/x/time/rate"

   "github.com/op/go-logging"
)

var log = logging.MustGetLogger("example")

// Example format string. Everything except the message has a custom color
// which is dependent on the log level. Many fields have a custom output
// formatting too, eg. the time returns the hour down to the milli second.
var format = logging.MustStringFormatter(
   `%{color}%{time:15:04:05.000} %{shortfunc} ▶ %{level:.4s} %{id:03x}%{color:reset} %{message}`,
)

func main() {

   backend1 := logging.NewLogBackend(os.Stderr, "", 0)
   backend2 := logging.NewLogBackend(os.Stderr, "", 0)
   backend2Formatter := logging.NewBackendFormatter(backend2, format)
   backend1Leveled := logging.AddModuleLevel(backend1)
   backend1Leveled.SetLevel(logging.ERROR, "")
   logging.SetBackend(backend1Leveled, backend2Formatter)

   r := rate.Every(1)
   limit := rate.NewLimiter(r, 10)
   for {
       if limit.AllowN(time.Now(), 8) {
           log.Info("log:event happen")
       } else {
           log.Info("log:event not allow")
       }

   }

}

网络请求频率限制大多用的Allow,如tollbooth,服务器在对每一个请求相应之前,先从令牌池中获取令牌,如果没有令牌可用,则忽略或丢弃当前请求。
tollbooth 可以基于方法,IP等进行限制,基本实现方法就是把方法、ip作为一个key,然后对每一个key关联一个Limiter。

    // Map of limiters without TTL
    tokenBucketsNoTTL map[string]*rate.Limiter

    // Map of limiters with TTL
    tokenBucketsWithTTL *gocache.Cache

gocache.Cache 也是一个map,不过还实现了”有效期“功能,如果某个key超过了有效期就会从map中清除,这个机制实现的很巧妙,会在以后的文章中介绍。

然后对于每一个网络请求,提取出key,然后判断key对应的Limiter是否有可用的令牌,如下:

func (l *Limiter) limitReachedNoTokenBucketTTL(key string) bool {
    l.Lock()
    defer l.Unlock()

    if _, found := l.tokenBucketsNoTTL[key]; !found {
        l.tokenBucketsNoTTL[key] = rate.NewLimiter(rate.Every(l.TTL), int(l.Max))
    }

    return !l.tokenBucketsNoTTL[key].AllowN(time.Now(), 1)
}

...

func (l *Limiter) limitReachedWithCustomTokenBucketTTL(key string, tokenBucketTTL time.Duration) bool {
    l.Lock()
    defer l.Unlock()

    if _, found := l.tokenBucketsWithTTL.Get(key); !found {
        l.tokenBucketsWithTTL.Set(
            key,
            rate.NewLimiter(rate.Every(l.TTL), int(l.Max)),
            tokenBucketTTL,
        )
    }

    expiringMap, found := l.tokenBucketsWithTTL.Get(key)
    if !found {
        return false
    }

    return !expiringMap.(*rate.Limiter).AllowN(time.Now(), 1)
}

测试ReserveN

参考YY哥

package main

import (
    "bytes"
    "fmt"
    "io"
    "time"

    "golang.org/x/time/rate"
)

type reader struct {
    r      io.Reader
    limiter *rate.Limiter
}

// Reader returns a reader that is rate limited by
// the given token bucket. Each token in the bucket
// represents one byte.
func NewReader(r io.Reader, l *rate.Limiter) io.Reader {
    return &reader{
        r:      r,
        limiter:l,
    }
}

func (r *reader) Read(buf []byte) (int, error) {
    n, err := r.r.Read(buf)
    if n <= 0 {
        return n, err
    }

    now := time.Now()
    rv := r.limiter.ReserveN(now, n)
    if !rv.OK() {
        return 0, fmt.Errorf("Exceeds limiter's burst")
    }
    delay := rv.DelayFrom(now)
    //fmt.Printf("Read %d bytes, delay %d\n", n, delay)
    time.Sleep(delay)
    return n, err
}

func main() {
    // Source holding 1MB
    src := bytes.NewReader(make([]byte, 1024*1024))
    // Destination
    dst := &bytes.Buffer{}

    // Bucket adding 100KB every second, holding max 100KB
    limit := rate.NewLimiter(100*1024, 100*1024)

    start := time.Now()

    buf := make([]byte, 10*1024)
    // Copy source to destination, but wrap our reader with rate limited one
    //io.CopyBuffer(dst, NewReader(src, limit), buf)
    r := NewReader(src, limit)
    for{
        if n, err := r.Read(buf); err == nil {
            dst.Write(buf[0:n])
        }else{
            break
        }
    }

    fmt.Printf("Copied %d bytes in %s\n", dst.Len(), time.Since(start))
}

后记

之前一直在CSDN上写文章,后面会逐步转换到简书上,还请大家多多支持。

推荐阅读更多精彩内容

  • Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具(例如配置管理,服务发现,断路器,智...
    卡卡罗2017阅读 121,860评论 17 134
  • 【子曰:“师挚之始,关雎之乱,洋洋乎盈耳哉。”】 师挚,是鲁国的太师,即首席乐师。关雎是大家最熟悉的《诗经》...
    友朴书房阅读 65评论 0 0
  • 1 来到公司已经一个月了,但是感觉已经过了一年的时间。 前两天晨会,公司董事长老夏宣布一个消息:我们公司过两天装几...
    邮递员王先森阅读 204评论 4 2
  • 多少年来,我们沉睡 确切地说,是埋在土里 任其腐烂,随便什么都可以蚕食 四季是给部分明亮准备的 而埋在土里的另一部...
    蘭蔻依阅读 180评论 1 2
  • 午后,阳光淡然,斟一杯咖啡,空气中流动着属于秋日独有的懒洋洋的气氛,安静的看完这部《咕咕是一只猫》,心情便在电影缓...
    暖M暖阅读 124评论 0 1