限流黑科技：秒杀、下单场景的救星

后端

2023-08-15 23:24:23

限流和熔断机制：互联网高并发的生命线

现代互联网的洪流挑战

当今的互联网世界充斥着高并发的业务场景。从疯狂的秒杀活动到常规的下单流程，从查询商品详情到支付操作，随时可能出现流量洪峰将系统淹没。在如此瞬息万变的环境中，保证系统的稳定运行，防止超负荷，就变得至关重要。

限流熔断机制的守护作用

限流熔断机制就像一道坚固的屏障，将汹涌的请求洪流限制在安全阈值内，守护着系统的稳定与健康。它确保请求的平稳处理，防止系统过载，从而保障用户体验和业务正常运行。

限流算法的百般武艺

限流算法是限流机制的核心。它们各有千秋，满足不同场景的限流需求。

1. 令牌桶算法：有序排队的公平限流

想象一个装满令牌的桶，每个请求都需要消耗一个令牌才能被处理。当桶内没有令牌时，请求将被拒绝。令牌桶算法保证了请求的公平性，防止某个请求独占所有资源。

class TokenBucket {
    private int capacity;
    private int tokens;
    private long lastUpdate;

    public TokenBucket(int capacity) {
        this.capacity = capacity;
        this.tokens = capacity;
    }

    public boolean allowRequest() {
        long now = System.currentTimeMillis();
        int newTokens = (int) ((now - lastUpdate) / 1000 * tokens);
        tokens = Math.min(capacity, tokens + newTokens);
        lastUpdate = now;

        if (tokens > 0) {
            tokens--;
            return true;
        } else {
            return false;
        }
    }
}

2. 漏桶算法：平稳泄洪的无差别限流

漏桶算法与令牌桶算法类似，但它没有存储令牌的功能。请求到来时，直接进入漏桶，然后以固定的速率流出。漏桶算法可以平滑请求的流量，防止流量突发。

class LeakyBucket {
    private double rate;
    private double tokens;

    public LeakyBucket(double rate) {
        this.rate = rate;
        this.tokens = 0;
    }

    public boolean allowRequest(double time) {
        tokens += rate * time;
        if (tokens > 1) {
            tokens = 1;
        }

        if (tokens > 0) {
            tokens--;
            return true;
        } else {
            return false;
        }
    }
}

3. 滑动窗口算法：动态调整的弹性限流

滑动窗口算法以一定时间窗口为单位，统计窗口内的请求数量。如果窗口内的请求数量超过阈值，则拒绝新的请求。滑动窗口算法可以动态调整限流阈值，适应流量的变化。

class SlidingWindow {
    private int windowSize;
    private int[] window;
    private int index;

    public SlidingWindow(int windowSize) {
        this.windowSize = windowSize;
        this.window = new int[windowSize];
        this.index = 0;
    }

    public boolean allowRequest() {
        window[index++] = 1;
        index = index % windowSize;

        int sum = 0;
        for (int i = 0; i < windowSize; i++) {
            sum += window[i];
        }

        if (sum > windowSize / 2) {
            return false;
        } else {
            return true;
        }
    }
}

4. 随机窗口算法：不拘一格的随机限流

随机窗口算法与滑动窗口算法类似，但它以随机的时间窗口为单位，统计窗口内的请求数量。随机窗口算法可以防止恶意请求的冲击，提高系统的稳定性。

class RandomWindow {
    private int minWindowSize;
    private int maxWindowSize;
    private int[] window;
    private int index;

    public RandomWindow(int minWindowSize, int maxWindowSize) {
        this.minWindowSize = minWindowSize;
        this.maxWindowSize = maxWindowSize;
        this.window = new int[maxWindowSize];
        this.index = 0;
    }

    public boolean allowRequest() {
        int windowSize = minWindowSize + (int) (Math.random() * (maxWindowSize - minWindowSize));
        window[index++] = 1;
        index = index % windowSize;

        int sum = 0;
        for (int i = 0; i < windowSize; i++) {
            sum += window[i];
        }

        if (sum > windowSize / 2) {
            return false;
        } else {
            return true;
        }
    }
}

限流策略的五花八门

限流策略是限流机制的另一个重要组成部分。根据不同的业务场景，可以采取不同的限流策略。

1. 拒绝请求：斩钉截铁的直接拒绝

拒绝请求是最简单粗暴的限流策略，直接拒绝超过限流阈值的请求。这种策略简单易行，但容易导致用户体验差。

public boolean limitRequest(int count) {
    if (count > limit) {
        return false;
    } else {
        return true;
    }
}

2. 排队等待：井然有序的排队等候

排队等待是相对温和的限流策略，当请求超过限流阈值时，将请求放入队列中等待处理。这种策略可以保证用户体验，但可能会导致请求延迟。

public boolean limitRequest(int count) {
    if (count > limit) {
        queue.offer(count);
        return false;
    } else {
        return true;
    }
}

3. 熔断：壮士断腕的果断熔断

熔断是一种保护系统的自我保护机制，当系统超负荷时，熔断器会自动关闭部分功能，保证核心功能的正常运行。熔断策略可以防止系统崩溃，但可能会导致部分用户无法使用某些功能。

public boolean limitRequest(int count) {
    if (count > limit) {
        circuitBreaker.trip();
        return false;
    } else {
        return true;
    }
}