golang框架中的限流算法有何优缺点？

package main

import (
    "context"
    "fmt"
    "time"

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

func main() {
    // 创建一个限制每秒 10 个请求的限流器
    limiter := rate.NewLimiter(10, 10)

    // 获取一个令牌，阻塞直到可用
    ctx := context.Background()
    if err := limiter.Wait(ctx); err != nil {
        fmt.Println(err)
        return
    }

    // 执行受限操作
    fmt.Println("受限操作已执行")
}

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

type TokenBucket struct {
    mu        sync.Mutex
    tokens    int
    refillRate int
    lastTime  time.Time
}

func NewTokenBucket(tokens, refillRate int) *TokenBucket {
    return &TokenBucket{
        tokens:    tokens,
        refillRate: refillRate,
        lastTime:  time.Now(),
    }
}

func (b *TokenBucket) Acquire(ctx context.Context) (bool, error) {
    b.mu.Lock()
    defer b.mu.Unlock()

    // 补充令牌
    now := time.Now()
    b.tokens += int(now.Sub(b.lastTime).Seconds()) * b.refillRate
    b.lastTime = now

    // 如果令牌已耗尽，阻塞直到可用
    for b.tokens <= 0 {
        if err := ctx.Err(); err != nil {
            return false, err
        }
        time.Sleep(time.Second)
        now = time.Now()
        b.tokens += int(now.Sub(b.lastTime).Seconds()) * b.refillRate
        b.lastTime = now
    }

    b.tokens--
    return true, nil
}

func main() {
    // 创建一个限制每秒 10 个请求的令牌桶
    bucket := NewTokenBucket(10, 10)

    // 执行受限操作
    if ok, err := bucket.Acquire(context.Background()); ok {
        fmt.Println("受限操作已执行")
    } else {
        fmt.Println(err)
    }
}

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

type SlidingWindow struct {
    mu        sync.Mutex
    window    []time.Time
    windowSize int
}

func NewSlidingWindow(windowSize int) *SlidingWindow {
    return &SlidingWindow{
        window:    []time.Time{},
        windowSize: windowSize,
    }
}

func (w *SlidingWindow) Acquire(ctx context.Context) (bool, error) {
    w.mu.Lock()
    defer w.mu.Unlock()

    // 移除窗口之外的请求
    for len(w.window) > 0 && w.window[0].Add(time.Duration(w.windowSize)*time.Second).Before(time.Now()) {
        w.window = w.window[1:]
    }

    // 如果窗口已满，阻塞直到可用
    for len(w.window) >= w.windowSize {
        if err := ctx.Err(); err != nil {
            return false, err
        }
        time.Sleep(time.Second)
    }

    // 添加新请求到窗口
    w.window = append(w.window, time.Now())
    return true, nil
}

func main() {
    // 创建一个限制每秒 10 个请求的滑动窗口
    window := NewSlidingWindow(10)

    // 执行受限操作
    if ok, err := window.Acquire(context.Background()); ok {
        fmt.Println("受限操作已执行")
    } else {
        fmt.Println(err)
    }
}