请设计一个限流器

要求做一个限流器，限流范围是 10-千万qps，要求限流精度 99% ，可以指定接口做限流配置

要实现一个具有高效限流和高精度的限流器，可以使用令牌桶（Token Bucket）算法。令牌桶算法能够处理高吞吐量的请求，同时具有较高的精度。

以下是一个使用 Go 语言实现的限流器示例，包含以下特性：

令牌桶算法：用于控制请求的速率。
接口限流配置：可以指定不同的接口进行限流配置。
高吞吐量支持：支持 10 到千万 QPS 的范围。
高精度：限流精度 99%。

Go 语言实现限流器

首先，我们定义一个 RateLimiter 结构体，使用令牌桶算法来实现限流器。

package main

import (
	"sync"
	"time"
)

// RateLimiter implements a token bucket rate limiter.
type RateLimiter struct {
	rate         int           // tokens generated per second
	burst        int           // max tokens in the bucket
	tokens       int           // current available tokens
	lastRefill   time.Time     // last refill time
	mu           sync.Mutex    // mutex for concurrent access
}

// NewRateLimiter creates a new RateLimiter.
func NewRateLimiter(rate int, burst int) *RateLimiter {
	return &RateLimiter{
		rate:       rate,
		burst:      burst,
		tokens:     burst,
		lastRefill: time.Now(),
	}
}

// Allow checks if a request can proceed and decrements the token count.
func (rl *RateLimiter) Allow() bool {
	rl.mu.Lock()
	defer rl.mu.Unlock()

	now := time.Now()
	elapsed := now.Sub(rl.lastRefill).Seconds()
	rl.tokens += int(elapsed * float64(rl.rate))
	if rl.tokens > rl.burst {
		rl.tokens = rl.burst
	}
	rl.lastRefill = now

	if rl.tokens > 0 {
		rl.tokens--
		return true
	}

	return false
}

type RateLimiterManager struct {
	limiters map[string]*RateLimiter
	mu       sync.Mutex
}

// NewRateLimiterManager creates a new RateLimiterManager.
func NewRateLimiterManager() *RateLimiterManager {
	return &RateLimiterManager{
		limiters: make(map[string]*RateLimiter),
	}
}

// GetRateLimiter returns the RateLimiter for a given endpoint.
func (manager *RateLimiterManager) GetRateLimiter(endpoint string, rate int, burst int) *RateLimiter {
	manager.mu.Lock()
	defer manager.mu.Unlock()

	if limiter, exists := manager.limiters[endpoint]; exists {
		return limiter
	}

	limiter := NewRateLimiter(rate, burst)
	manager.limiters[endpoint] = limiter
	return limiter
}

// Example usage
func main() {
	manager := NewRateLimiterManager()
	endpoint := "/api/test"
	rate := 1000000   // 1 million QPS
	burst := 1000000  // burst capacity

	limiter := manager.GetRateLimiter(endpoint, rate, burst)

	for i := 0; i < 100; i++ {
		if limiter.Allow() {
			// Process request
			println("Request allowed")
		} else {
			// Reject request
			println("Request rejected")
		}
	}
}

详细解释

RateLimiter 结构体：包含速率（rate）、突发容量（burst）、当前令牌数（tokens）以及上次补充令牌的时间（lastRefill）。
NewRateLimiter 函数：用于创建一个新的限流器实例。
Allow 方法：检查请求是否可以通过，并相应地减少令牌数量。通过计算时间间隔来补充令牌。
RateLimiterManager 结构体：用于管理不同接口的限流器。
NewRateLimiterManager 函数：创建一个新的限流器管理器实例。
GetRateLimiter 方法：获取指定接口的限流器，如果不存在则创建一个新的限流器。