高并发下限流的精彩对策：辨析与方案

2023-11-02 19:43:58

限流算法与方案：确保高并发应用的稳定运行

在互联网飞速发展的大数据时代，高并发应用早已成为普遍场景。面对海量请求和数据的冲击，系统如何稳定运行？限流算法应运而生，犹如交通管理中的“红绿灯”，通过控制请求流量，避免系统因过载而崩溃。本文将深入探讨高并发场景下常见的限流算法及方案，助您掌握系统限流策略。

限流算法的奥秘

限流算法是一种控制请求流量的策略，核心思想是限制单位时间内的请求数量。常见的限流算法有：

漏桶算法： 将请求视为水滴，按照固定速率将其滴入漏斗。若漏斗已满，则后续请求将被丢弃。适用于瞬时请求流量较大的场景。

class LeakyBucket {
    private int capacity; // 漏桶容量
    private int rate; // 漏水速率
    private int count; // 当前水位

    public LeakyBucket(int capacity, int rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.count = 0;
    }

    public boolean allowRequest() {
        count -= rate; // 漏水
        if (count < 0) {
            count = 0;
        }
        if (count + 1 <= capacity) {
            count++;
            return true;
        }
        return false;
    }
}

令牌桶算法： 令牌的产生速率是固定的。当请求到达时，先获取令牌，再处理请求。若无令牌，则请求会被丢弃。适用于持续时间较长的请求。

class TokenBucket {
    private int capacity; // 桶容量
    private int rate; // 令牌产生速率
    private int count; // 当前令牌数

    public TokenBucket(int capacity, int rate) {
        this.capacity = capacity;
        this.rate = rate;
        this.count = 0;
    }

    public boolean allowRequest() {
        count -= rate; // 减少令牌数
        if (count < 0) {
            count = 0;
        }
        if (count + 1 <= capacity) {
            count++;
            return true;
        }
        return false;
    }
}

窗口计数器算法： 将时间划分为窗口，统计每个窗口内的请求数量。若窗口内请求数量超过阈值，则后续请求会被丢弃。适用于流量变化较大的场景。

class WindowCounter {
    private int windowSize; // 窗口大小（单位：时间）
    private int threshold; // 阈值
    private int[] windowCounts; // 窗口内请求计数
    private int windowIndex; // 当前窗口索引

    public WindowCounter(int windowSize, int threshold) {
        this.windowSize = windowSize;
        this.threshold = threshold;
        this.windowCounts = new int[windowSize];
        this.windowIndex = 0;
    }

    public boolean allowRequest() {
        windowCounts[windowIndex]++; // 计数加1
        int sum = 0;
        for (int i = 0; i < windowSize; i++) {
            sum += windowCounts[i];
        }
        if (sum <= threshold) {
            return true;
        }
        return false;
    }
}

限流方案的宝库

除了限流算法，还有多种限流方案可供选择：

Redis限流： 利用Redis实现限流，方法是在Redis中设置一个键，存储请求次数。当请求到达时，先检查键的值是否超过阈值，若超过，则丢弃请求，否则将键的值加1。

import redis.clients.jedis.Jedis;

public class RedisRateLimiter {
    private Jedis jedis;
    private String key; // 限流键
    private int limit; // 限流阈值

    public RedisRateLimiter(Jedis jedis, String key, int limit) {
        this.jedis = jedis;
        this.key = key;
        this.limit = limit;
    }

    public boolean allowRequest() {
        long count = jedis.incr(key); // 计数加1
        if (count <= limit) {
            return true;
        }
        return false;
    }
}

Nginx限流： 利用Nginx实现限流，方法是在Nginx配置文件中设置限流规则。当请求到达时，Nginx会根据规则判断是否允许请求通过。

limit_req_zone $binary_remote_addr zone=mylimit:10m rate=5r/s;

server {
    ...
    location / {
        limit_req zone=mylimit burst=5;
        ...
    }
    ...
}