高可用之限流

大袤宏图

已于 2024-06-15 15:31:02 修改

阅读量243

点赞数 8

文章标签：笔记可用性测试

于 2024-06-04 21:18:50 首次发布

本文链接：https://blog.csdn.net/mao1994aa/article/details/139453697

版权

限流是服务端架构中常用的一种策略，用于控制访问频率，防止系统过载。以下是一些常见的限流方法及其比较：

1. 固定窗口计数器法

原理：将时间分为多个固定窗口（例如每分钟），在每个窗口内计数器增加请求数。
优点：简单易实现。
缺点：在窗口切换时可能出现请求高峰，导致瞬时压力。

2. 滑动窗口计数器法

原理：使用滑动窗口代替固定窗口，记录每个时间点的请求数，窗口滑动时丢弃最旧的请求计数。
优点：更平滑，可以更精确地控制请求速率。
缺点：实现相对复杂，需要维护一个时间序列的计数器。

3. 漏桶算法

原理：将请求比作水滴，漏桶比作固定容量的桶，水以固定速率流出，请求以固定速率处理。
优点：平滑处理请求，避免突发流量。
缺点：处理速率固定，不能应对突发流量。

4. 令牌桶算法

原理：令牌以固定速率生成，请求需要消耗令牌才能被处理，令牌桶有固定容量。
优点：允许一定的突发流量，可以平滑请求。
缺点：需要维护令牌生成和消耗的机制。

在Java中实现令牌桶限流算法通常涉及到创建一个令牌桶，按照固定的速率向桶中添加令牌，并且每次请求到来时尝试从桶中移除一个令牌。如果桶中有足够的令牌，则允许请求通过；如果没有，则请求被限流。

以下是一个简单的单机令牌桶限流算法的Java实现示例：

import java.util.concurrent.*;

public class TokenBucket {
    private final long capacity; // 桶的容量
    private final long rate; // 每秒生成的令牌数
    private final long interval; // 生成令牌的时间间隔，单位为毫秒
    private final BlockingQueue<Long> tokens; // 存储令牌的时间戳
    private final AtomicLong availableTokens = new AtomicLong(0); // 当前可用的令牌数

    public TokenBucket(long capacity, long rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.interval = 1000L / rate; // 计算时间间隔
        this.tokens = new LinkedBlockingQueue<>(capacity);
        for (long i = 0; i < capacity; i++) {
            tokens.add(System.nanoTime());
        }
        availableTokens.set(capacity);
    }

    public boolean take() throws InterruptedException {
        long now = System.nanoTime();
        while (!tokens.isEmpty()) {
            long tokenTime = tokens.peek();
            if (now - tokenTime >= 0) {
                tokens.poll();
                availableTokens.incrementAndGet();
                return true;
            }
        }
        // 如果桶为空，等待新令牌生成
        long waitTime = interval - (now % interval);
        Thread.sleep(waitTime / 1_000_000);
        return availableTokens.incrementAndGet() <= capacity;
    }
}

对于分布式限流，单机的令牌桶算法需要扩展以支持跨多个节点的协调。以下是一些实现分布式限流的常见方法：

1. **使用分布式缓存**：使用Redis等分布式缓存系统来存储令牌桶状态。令牌的生成和消耗操作需要在所有节点之间同步。

2. **使用分布式锁**：在生成令牌时使用分布式锁来保证操作的原子性，避免多个节点同时生成令牌。

3. **使用消息队列**：通过消息队列来协调不同节点的令牌生成和消费，确保全局的令牌生成速率。

以下是一个使用Redis实现分布式令牌桶限流的示例伪代码：

public class DistributedTokenBucket {
    private final Jedis jedis; // Redis客户端
    private final String tokenKey; // 存储令牌的Redis键
    private final long capacity;
    private final long rate;
    private final long refillInterval;

    public DistributedTokenBucket(Jedis jedis, String tokenKey, long capacity, long rate) {
        this.jedis = jedis;
        this.tokenKey = tokenKey;
        this.capacity = capacity;
        this.rate = rate;
        this.refillInterval = 1000L / rate;
    }

    public boolean take() {
        long now = System.currentTimeMillis();
        long tokensToAdd = (now / refillInterval) - (jedis.getSet(tokenKey + ":timestamp", String.valueOf(now)) != null ? Long.parseLong(jedis.get(tokenKey + ":timestamp")) / refillInterval : 0);
        if (tokensToAdd > 0) {
            long newTokens = Math.min(tokensToAdd, capacity - jedis.llen(tokenKey));
            jedis.lpush(tokenKey, String.valueOf(System.nanoTime()));
            jedis.ltrim(tokenKey, 0, (int) (capacity - 1));
        }
        
        if (jedis.lpop(tokenKey) != null) {
            return true;
        } else {
            return false;
        }
    }
}

在这个示例中，我们使用Redis的列表来存储令牌，使用`LPUSH`来添加令牌，使用`LPOP`来消费令牌。我们还使用了一个额外的键来存储最后生成令牌的时间戳，以确保在分布式环境中以正确的速率生成令牌。

请注意，这只是一个简化的示例，实际的分布式限流实现可能需要考虑更多的因素，如令牌的过期、错误处理、高可用性等。