一、什么是削峰填谷：

某瞬时来了大流量的请求, 而如果此时要处理所有请求，很可能会导致系统负载过高，影响稳定性。但其实可能后面几秒之内都没有消息投递，若直接把多余的消息丢掉则没有充分利用系统处理消息的能力。Sentinel的Rate Limiter模式能在某一段时间间隔内以匀速方式处理这样的请求, 充分利用系统的处理能力, 也就是削峰填谷, 保证资源的稳定性.
Sentinel会以固定的间隔时间让请求通过, 访问资源。当请求到来的时候，如果当前请求距离上个通过的请求通过的时间间隔不小于预设值，则让当前请求通过；否则，计算当前请求的预期通过时间，如果该请求的预期通过时间小于规则预设的 timeout 时间，则该请求会等待直到预设时间到来通过；反之，则马上抛出阻塞异常。
使用Sentinel的这种策略, 简单点说, 就是使用一个时间段(比如20s的时间)处理某一瞬时产生的大量请求, 起到一个削峰填谷的作用, 从而充分利用系统的处理能力, 下图能很形象的展示这种场景: X轴代表时间, Y轴代表系统处理的请求.

image.png

二、验证

模拟1000个请求同时并发的访问资源, 这1000个请求, 如果设置QPS阈值为100, 按照默认sentinel默认的RuleConstant.CONTROL_BEHAVIOR_DEFAULT拒绝策略, 那么剩余的900个请求会被立即直接拒绝掉, 抛出BlockException.

image.png

同样是模拟1000个请求同时并发访问资源, 同样设置QPS阈值100, 但是拒绝策略修改为Rate Limiter匀速RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER方式, 还需要设置setMaxQueueingTimeMs(20 * 1000)表示每一请求最长等待时间, 这里等待时间大一点, 以保证让所有请求都能正常通过。
假设这里设置的排队等待时间过小的话, 导致排队等待的请求超时而抛出异常BlockException, 最终结果可能是这1000个并发请求中只有几个请求或几十个才能正常通过, 所以使用这种模式得根据访问资源的耗时时间决定排队等待时间。
按照目前这种设置, QPS阈值为100的话, 每一个请求相当于是以匀速10ms左右通过。

@GetMapping("/paceFlow")
    public void paceFlow() throws InterruptedException{
        System.out.println("pace behavior");
        countDown = new CountDownLatch(1);
        // queuing队列方式, 匀速处理流量
        initPaceFlowRule();
        // 直接并发同时启动1000个线程, 模拟1000个并发请求资源
        simulatePulseFlow();
        countDown.await();

        System.out.println("done");
        System.out.println("total pass:" + pass.get() + ", total block:" + block.get());

        System.out.println();
    }

匀速模式的规则

private static void initPaceFlowRule() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule1 = new FlowRule();
        rule1.setResource(KEY);
        rule1.setCount(count);
        rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule1.setLimitApp("default");
        /*
         * CONTROL_BEHAVIOR_RATE_LIMITER means requests more than threshold will be queueing in the queue, until the
         * queueing time is more than {@link FlowRule#maxQueueingTimeMs}, the requests will be rejected.
         */
        rule1.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER);
        // 这里设置的等待处理时间较大, 让系统能平稳的处理所有的请求
        rule1.setMaxQueueingTimeMs(20 * 1000);// 表示每一个请求的最长等待时间20s
        rules.add(rule1);
        FlowRuleManager.loadRules(rules);
    }

并发启动1000线程模拟请求

private static void simulatePulseFlow() {
        for (int i = 0; i < requestQps; i++) {
            Thread thread = new Thread(new Runnable() {

                @Override
                public void run() {
                    long startTime = TimeUtil.currentTimeMillis();
                    Entry entry = null;
                    try {
                        entry = SphU.entry(KEY);
                        pass.incrementAndGet();
                    } catch (BlockException e1) {
                        System.out.println("===>BlockException");
                        block.incrementAndGet();
                    } catch (Exception e2) {
                        // biz exception
                    } finally {
                        if (entry != null) {
                            entry.exit();
                            // pass.incrementAndGet();
                            long cost = TimeUtil.currentTimeMillis() - startTime;
                            System.out.println(TimeUtil.currentTimeMillis() + " one request pass, cost " + cost
                                    + " ms");
                        }
                    }

                    try {
                        TimeUnit.MILLISECONDS.sleep(5);
                    } catch (InterruptedException e1) {
                        // ignore
                    }

                    if (done.incrementAndGet() >= requestQps) {
                        countDown.countDown();
                    }
                }
            }, "Thread " + i);
            thread.start();
        }
    }

启动后控制台打印：