在 go 框架中，限流算法可保护系统免受高并发影响，其中包括：1. 信号量：使用计数器限制并发请求数量，简单易用，但无法动态调整限制；2. 令牌桶：存储固定数量的令牌，平滑请求流量，但配置较复杂；3. 滑动窗口：记录一定时间窗口内的请求数量，动态调整限制，但实现较复杂。根据具体场景选择合适的限流算法至关重要。

Go 框架中的限流算法

在高并发系统中，限流算法至关重要，它可以保护系统免受过载和崩溃的影响。Go 框架内置了多种限流算法，各有优缺点。

1. 信号量

立即学习“go语言免费学习笔记（深入）”；

信号量是一种简单的算法，它使用计数器来限制并发请求的数量。它的优点是简单易用，缺点是不能根据需要动态调整限制。

package main

import (
    "context"
    "fmt"
    "time"

    "<a style='color:#f60; text-decoration:underline;' href="https://www.php.cn/zt/16009.html" target="_blank">golang</a>.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("受限操作已执行")
}

2. 令牌桶

令牌桶是一种更复杂的算法，它存储了一个固定数量的令牌。当需要执行一个请求时，会从桶中取出一枚令牌。如果没有可用的令牌，请求将被阻塞。令牌桶的优点是可以平滑请求流量，缺点是配置较复杂。

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)
    }
}

3. 滑动窗口

滑动窗口是一个更精确的算法，它记录一定时间窗口内的请求数量。当请求数量超过阈值时，限制将被触发。滑动窗口的优点是可以根据需要动态调整限制，缺点是实现比较复杂。

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)
    }
}

选择合适的限流算法取决于具体场景的具体要求。信号量简单易用，适用于限制并发请求数量。令牌桶可以平滑请求流量，适用于稳定高并发的场景。滑动窗口可以根据需要动态调整限制，适用于对实时性要求较高的场景。