Go в примерах: Ограничение скорости (Rate Limiting)

Ограничение скорости (Rate limiting) — важный способ для управления использованием ресурсов и обеспечения качества обслуживания. Go предлагает элегантный способ ограничения скорости с помощью горутин, каналов и счётчиков тиков.

 
package main

import "time"
import "fmt"

func main() {

Сначала обратим внимание на базовое ограничение скорости. Предположим, что нужно ограничить скорость обработки входящих запросов. Будем брать эти запросы из канала requests.

 
    requests := make(chan int, 5)
    for i := 1; i <= 5; i++ {
        requests <- i
    }
    close(requests)

Канал limiter будет получать значение каждые 200 миллисекунд. Это будет регулятор скорости в нашей схеме.

 
    limiter := time.Tick(time.Millisecond * 200)

С помощью блокировки приёма значения из канала limiter перед обработкой каждого запроса, ограничимся 1 запросом в 200 миллисекунд.

 
    for req := range requests {
        <-limiter
        fmt.Println("request", req, time.Now())
    }

Может потребоваться организовать небольшие пакеты запросов в схеме ограничения скорости с сохранением общего ограничения скорости. Это можно сделать с помощью буфера канала-ограничителя burstyLimiter. Такой канал позволяет использовать размер пакета велчиной до 3 событий.

 
    burstyLimiter := make(chan time.Time, 3)

Заполним канал для того, чтобы показать позволенный размер пакета

 
    for i := 0; i < 3; i++ {
        burstyLimiter <- time.Now()
    }

Каждые 200 миллисекунд пробуем добавить новое значение в канал burstyLimiter до предела в 3 значения.

 
    go func() {
        for t := range time.Tick(time.Millisecond * 200) {
            burstyLimiter <- t
        }
    }()

Теперь имитируем 5 входящих запросов. Первые 3 из них получат преимущество из-за возможности пакетной обработки burstyLimiter.

 
    burstyRequests := make(chan int, 5)
    for i := 1; i <= 5; i++ {
        burstyRequests <- i
    }
    close(burstyRequests)
    for req := range burstyRequests {
        <-burstyLimiter
        fmt.Println("request", req, time.Now())
    }
}

При запуске программы первый набор запросов обработается с паузой ~200 мсек. каждый, что и требовалось.

 
$ go run rate-limiting.go
request 1 2012-10-19 00:38:18.687438 +0000 UTC
request 2 2012-10-19 00:38:18.887471 +0000 UTC
request 3 2012-10-19 00:38:19.087238 +0000 UTC
request 4 2012-10-19 00:38:19.287338 +0000 UTC
request 5 2012-10-19 00:38:19.487331 +0000 UTC

Из второго набора запросов мы обработаем первые 3 немедленно, благодаря пакетному ограниченю скорости, а затем обработаем оставшиеся 2 с паузой в ~200 мсек.

 
request 1 2012-10-19 00:38:20.487578 +0000 UTC
request 2 2012-10-19 00:38:20.487645 +0000 UTC
request 3 2012-10-19 00:38:20.487676 +0000 UTC
request 4 2012-10-19 00:38:20.687483 +0000 UTC
request 5 2012-10-19 00:38:20.887542 +0000 UTC

Следующий пример: Атомарные счётчики (Atomic Counters).

придумал @mmcgrana | перевел @village_geek | исходники | лицензия