使用滑动窗口统计访问频次，进行限流

如题

package slidingwindow

import (
    "errors"
    "sync"
    "time"
)

// Window window
type Window struct {
    sync.RWMutex

    window   time.Duration
    tick     time.Duration
    samples  []int64
    stopOnce sync.Once
    stopping chan struct{}
    pos      int
    size     int
}

// New new window
// New(time.Second*5, time.Second)
func New(window, tick time.Duration) (*Window, error) {
    if window == 0 {
        return nil, errors.New("sliding window cannot be zero")
    }

    if tick == 0 {
        return nil, errors.New("tick cannot be zero")
    }

    if window <= tick || window%tick != 0 {
        return nil, errors.New("window size has to be a multiplier of granularity size")
    }

    win := &Window{
        window:   window,
        tick:     tick,
        samples:  make([]int64, int(window/tick)),
        stopping: make(chan struct{}, 1),
    }

    go win.shifter()

    return win, nil
}

func (win *Window) shifter() {
    ticker := time.NewTicker(win.tick)

    for {
        select {
        case <-ticker.C:
            win.slidingWindow()
        case <-win.stopping:
            return
        }
    }
}

func (win *Window) slidingWindow() {
    win.Lock()
    defer win.Unlock()

    win.pos = win.pos + 1
    if win.pos >= len(win.samples) {
        win.pos = 0
    }
    win.samples[win.pos] = 0
}

// Add increments the value of the current sample.
func (win *Window) Add() {
    win.Lock()
    defer win.Unlock()
    win.samples[win.pos]++
}

// AddCount increments the value of the current sample.
func (win *Window) AddCount(n int64) {
    win.Lock()
    defer win.Unlock()
    win.samples[win.pos] += n
}

// Reset the samples in this sliding time window.
func (win *Window) Reset() {
    win.Lock()
    defer win.Unlock()

    win.pos, win.size = 0, 0
    for i := range win.samples {
        win.samples[i] = 0
    }
}

// Total returns the sum of all values over the window
func (win *Window) Total() int64 {

    win.RLock()
    defer win.RUnlock()

    var total int64
    for i := range win.samples {
        total += win.samples[i]
    }
    return total
}

// Stop the shifter of this sliding time window. A stopped SlidingWindow cannot
// be started again.
func (win *Window) Stop() {
    win.stopOnce.Do(func() {
        win.stopping <- struct{}{}
    })
}