限流器的核心玩法，划重点！

2024-01-06 18:07:35

限流：保护系统免受过载的盾牌

在当今高度互联的世界中，网站、应用程序和微服务面临着来自世界各地的大量并发请求。如果得不到适当管理，这种大流量可能会导致系统崩溃、性能下降和不公平的资源分配。限流在这里发挥着至关重要的作用，作为一种软件组件，它通过限制请求速率来保护系统免受过载。

限流器的妙用

限流器提供了多种好处，使其成为系统保护和性能优化的必备工具：

抵御请求洪峰： 限流器可以通过在服务器容量允许的范围内处理请求，防止大规模请求洪峰压垮系统。
优化系统性能： 通过限制请求速率，限流器可以减轻系统压力，从而提高响应时间和吞吐量。
公平分配资源： 限流器确保少数用户或应用程序不会独占系统资源，从而为所有用户提供公平的访问机会。

常见的限流算法

有多种限流算法可供选择，每种算法都有其优点和缺点。以下是四种最常见的算法：

令牌桶： 限制器向桶中添加令牌，请求访问时从桶中获取令牌。如果没有令牌，则拒绝请求。
滑动窗口： 限制器记录一段时间内的请求数。如果请求数超过阈值，则拒绝请求。
漏桶： 限制器以固定的速度从桶中漏出令牌。请求访问时从桶中获取令牌。如果没有令牌，则拒绝请求。
Redis 限流： 利用 Redis 的原子性操作和时间复杂度特性来实现限流功能。

用 Python、Java 和 Go 语言实现限流器

以下代码示例演示了如何使用 Python、Java 和 Go 语言实现一个简单的限流器：

Python

class RateLimiter:
    def __init__(self, limit, window):
        self.limit = limit
        self.window = window
        self.tokens = limit
        self.last_reset = time()

    def is_allowed(self):
        now = time()
        if now - self.last_reset >= self.window:
            self.tokens = self.limit
            self.last_reset = now
        if self.tokens > 0:
            self.tokens -= 1
            return True
        else:
            return False

Java

import java.util.concurrent.atomic.AtomicInteger;

public class RateLimiter {
    private final AtomicInteger tokens;
    private final long window;
    private final long lastReset;

    public RateLimiter(int limit, long window) {
        this.tokens = new AtomicInteger(limit);
        this.window = window;
        this.lastReset = System.currentTimeMillis();
    }

    public boolean isAllowed() {
        long now = System.currentTimeMillis();
        if (now - lastReset >= window) {
            tokens.set(limit);
            lastReset = now;
        }
        if (tokens.get() > 0) {
            tokens.decrementAndGet();
            return true;
        } else {
            return false;
        }
    }
}

Go 语言

package main

import (
    "fmt"
    "sync"
    "time"
)

type RateLimiter struct {
    mu        sync.Mutex
    limit     int
    window    time.Duration
    lastReset time.Time
    tokens    int
}

func NewRateLimiter(limit int, window time.Duration) *RateLimiter {
    return &RateLimiter{
        limit:     limit,
        window:    window,
        lastReset: time.Now(),
        tokens:    limit,
    }
}

func (r *RateLimiter) IsAllowed() bool {
    r.mu.Lock()
    defer r.mu.Unlock()

    now := time.Now()
    if now.Sub(r.lastReset) >= r.window {
        r.tokens = r.limit
        r.lastReset = now
    }
    if r.tokens > 0 {
        r.tokens--
        return true
    } else {
        return false
    }
}

func main() {
    limiter := NewRateLimiter(10, time.Second)

    for i := 0; i < 100; i++ {
        if limiter.IsAllowed() {
            fmt.Println("Request allowed")
        } else {
            fmt.Println("Request denied")
        }
    }
}