4. 滑动窗口限流算法：解决固定窗口边界突刺问题，基于环形数组的Go实现

固定窗口算法（如每秒允许100个请求）存在一个经典缺陷：边界突刺。假设窗口大小为1秒，阈值100。如果请求在第0.9秒到第1.0秒之间集中发送100个，紧接着在第1.0秒到第1.1秒之间又集中发送100个，那么在这0.2秒的时间段内，系统实际承受了200个请求的冲击，远超阈值。滑动窗口算法通过将时间窗口细分为多个小格子，让窗口平滑移动，从而消除边界突刺。

4.1 滑动窗口 vs 固定窗口：边界突刺对比

4.2 环形数组实现原理

使用环形数组（Circular Array / Ring Buffer）是实现滑动窗口最高效的方式之一。它避免了频繁的数组元素移动，仅通过移动头尾指针来维护窗口。

1. 数据结构： 一个固定长度的数组 buckets[N]，每个元素存储一个子窗口的请求计数。两个指针：head（指向最旧的子窗口）、tail（指向最新的子窗口）。一个变量 totalCount 缓存当前窗口总计数。
2. 滑动逻辑： 当时间前进到新的子窗口时，tail 指针向前移动一位（取模）。如果 tail 追上了 head，说明窗口已满，需要将 head 也向前移动一位（丢弃最旧子窗口），并从 totalCount 中减去被丢弃子窗口的计数。
3. 请求到达： 计算当前时间所属的子窗口索引。如果该子窗口已过期（被 head 跳过），则重置其计数为0。递增该子窗口计数，同时递增 totalCount。
4. 限流判断： 检查 totalCount 是否超过阈值。若超过，则拒绝请求。

4.3 Go 语言实现：基于环形数组的滑动窗口限流器

以下实现使用环形数组存储子窗口计数，通过 sync.Mutex 保证并发安全。核心方法包括 Allow() 和 AllowN()。

package slidingwindow

import (
    "sync"
    "time"
)

// SlidingWindow 滑动窗口限流器
type SlidingWindow struct {
    mu          sync.Mutex
    buckets     []int64        // 环形数组，存储每个子窗口的计数
    head        int            // 指向最旧子窗口
    tail        int            // 指向最新子窗口
    totalCount  int64          // 当前窗口总计数
    windowSize  time.Duration  // 窗口总大小（如 1s）
    bucketSize  time.Duration  // 子窗口大小（如 100ms）
    threshold   int64          // 阈值
    lastTime    time.Time      // 上次请求时间，用于计算偏移
}

// NewSlidingWindow 创建一个滑动窗口限流器
// windowSize: 窗口总大小，如 1*time.Second
// bucketCount: 子窗口数量，如 10
// threshold: 阈值
func NewSlidingWindow(windowSize time.Duration, bucketCount int, threshold int64) *SlidingWindow {
    bucketSize := windowSize / time.Duration(bucketCount)
    return &SlidingWindow{
        buckets:    make([]int64, bucketCount),
        head:       0,
        tail:       bucketCount - 1,
        windowSize: windowSize,
        bucketSize: bucketSize,
        threshold:  threshold,
        lastTime:   time.Now(),
    }
}

// Allow 判断是否允许一个请求通过
func (sw *SlidingWindow) Allow() bool {
    return sw.AllowN(1)
}

// AllowN 判断是否允许 N 个请求通过
func (sw *SlidingWindow) AllowN(n int64) bool {
    sw.mu.Lock()
    defer sw.mu.Unlock()

    now := time.Now()
    sw.advance(now)

    if sw.totalCount+n > sw.threshold {
        return false
    }

    // 更新当前子窗口计数
    sw.buckets[sw.tail] += n
    sw.totalCount += n
    return true
}

// advance 推进窗口到当前时间
func (sw *SlidingWindow) advance(now time.Time) {
    elapsed := now.Sub(sw.lastTime)
    if elapsed < sw.bucketSize {
        return // 仍在当前子窗口内，无需滑动
    }

    // 计算需要滑动的格子数
    steps := int(elapsed / sw.bucketSize)
    bucketCount := len(sw.buckets)

    for i := 0; i < steps; i++ {
        // tail 前进一格
        sw.tail = (sw.tail + 1) % bucketCount

        // 如果 tail 追上了 head，说明窗口已满，需要丢弃最旧子窗口
        if sw.tail == sw.head {
            // 丢弃 head 指向的旧格子
            sw.totalCount -= sw.buckets[sw.head]
            sw.buckets[sw.head] = 0
            sw.head = (sw.head + 1) % bucketCount
        }

        // 重置新 tail 格子（可能被旧数据占据）
        sw.buckets[sw.tail] = 0
    }

    sw.lastTime = now
}

// CurrentCount 返回当前窗口总计数
func (sw *SlidingWindow) CurrentCount() int64 {
    sw.mu.Lock()
    defer sw.mu.Unlock()
    sw.advance(time.Now())
    return sw.totalCount
}

4.4 使用示例与测试

package main

import (
    "fmt"
    "time"
    "your-project/slidingwindow"
)

func main() {
    // 创建滑动窗口限流器：窗口1秒，10个子窗口，阈值100
    sw := slidingwindow.NewSlidingWindow(1*time.Second, 10, 100)

    // 模拟请求
    for i := 0; i < 120; i++ {
        if sw.Allow() {
            fmt.Printf("请求 %d: 通过\n", i+1)
        } else {
            fmt.Printf("请求 %d: 被限流\n", i+1)
        }
        time.Sleep(10 * time.Millisecond) // 每10ms发一个请求
    }

    // 输出最终计数
    fmt.Printf("当前窗口计数: %d\n", sw.CurrentCount())
}

4.5 滑动窗口 vs 令牌桶 vs 漏桶：选型建议