分布式服务限流&微服务限流

文章内容输出来源：拉勾教育Java高薪训练营

1.什么是限流

限流可以认为服务降级的一种，限流就是限制系统的输入和输出流量已达到保护系统的目的。一般来说系统的吞吐量是可以被测算的，为了保证系统的稳定运行，一旦达到的需要限制的阈值，就需要限制流量并采取一些措施以完成限制流量的目的。比如：延迟处理，拒绝处理，或者部分拒绝处理等等。

2.常用的限流方法

（1）计数器法
（2）滑动窗口
（3）Leaky Bucket 漏桶
（4）Token Bucket 令牌桶

---

（1）计数器法
实现方式：控制单位时间内的请求数量

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    /**
     * 最大访问数量
     */
    private final int limit = 10;
    /**
     * 访问时间差
     */
    private final long timeout = 1000;
    /**
     * 请求时间
     */
    private long time;
    /**
     * 当前计数器
     */
    private AtomicInteger reqCount = new AtomicInteger(0);

    public boolean limit() {
        long now = System.currentTimeMillis();
        if (now < time + timeout) {
            // 单位时间内
            reqCount.addAndGet(1);
            return reqCount.get() <= limit;
        } else {
            // 超出单位时间
            time = now;
            reqCount = new AtomicInteger(0);
            return true;
        }
    }
}

缺点：控制粒度太粗，或控制不精确，假设在 00:01 时发生一个请求，在 00:01-00:58 之间不在发送请求，在 00:59 时发送剩下的所有请求 n-1 (n为限流请求数量)，在下一分钟的 00:01 发送n个请求,这样在2秒钟内请求到达了 2n - 1 个。设每分钟请求数量为60个,每秒可以处理1个请求，用户在 00:59 发送 60 个请求，在 01:00 发送 60 个请求，此时2秒钟有120个请求(每秒60个请求)，远远大于了每秒钟处理数量的阈值。

（2）滑动窗口

实现方式：滑动窗口是对计数器方式的改进, 增加一个时间粒度的度量单位，即把一分钟分成若干等分(6份,每份10秒), 在每一份上设置独立计数器,在 00:00-00:09 之间发生请求计数器累加1。当等分数量越大限流统计就越详细。

package com.example.demo1.service;

import java.util.Iterator;
import java.util.Random;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.stream.IntStream;

public class TimeWindow {
    private ConcurrentLinkedQueue<Long> queue = new ConcurrentLinkedQueue<Long>();

    /**
     * 间隔秒数
     */
    private int seconds;

    /**
     * 最大限流
     */
    private int max;

    public TimeWindow(int max, int seconds) {
        this.seconds = seconds;
        this.max = max;

        /**
         * 永续线程执行清理queue 任务
         */
        new Thread(() -> {
            while (true) {
                try {
                    // 等待 间隔秒数-1 执行清理操作
                    Thread.sleep((seconds - 1) * 1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                clean();
            }
        }).start();

    }

    public static void main(String[] args) throws Exception {

        final TimeWindow timeWindow = new TimeWindow(10, 1);

        // 测试3个线程
        IntStream.range(0, 3).forEach((i) -> {
            new Thread(() -> {

                while (true) {

                    try {
                        Thread.sleep(new Random().nextInt(20) * 100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    timeWindow.take();
                }

            }).start();

        });

    }

    /**
     * 获取令牌，并且添加时间
     */
    public void take() {

        long start = System.currentTimeMillis();
        try {

            int size = sizeOfValid();
            if (size > max) {
                System.err.println("超限");

            }
            synchronized (queue) {
                if (sizeOfValid() > max) {
                    System.err.println("超限");
                    System.err.println("queue中有 " + queue.size() + " 最大数量 " + max);
                }
                this.queue.offer(System.currentTimeMillis());
            }
            System.out.println("queue中有 " + queue.size() + " 最大数量 " + max);

        }

    }

    public int sizeOfValid() {
        Iterator<Long> it = queue.iterator();
        Long ms = System.currentTimeMillis() - seconds * 1000;
        int count = 0;
        while (it.hasNext()) {
            long t = it.next();
            if (t > ms) {
                // 在当前的统计时间范围内
                count++;
            }
        }

        return count;
    }

    /**
     * 清理过期的时间
     */
    public void clean() {
        Long c = System.currentTimeMillis() - seconds * 1000;

        Long tl = null;
        while ((tl = queue.peek()) != null && tl < c) {
            System.out.println("清理数据");
            queue.poll();
        }
    }

}

（3）Leaky Bucket 漏桶

实现方式：规定固定容量的桶，有水进入，有水流出。对于流进的水我们无法估计进来的数量、速度，对于流出的水我们可以控制速度。

public class LeakBucket {
    /**
     * 时间
     */
    private long time;
    /**
     * 总量
     */
    private Double total;
    /**
     * 水流出去的速度
     */
    private Double rate;
    /**
     * 当前总量
     */
    private Double nowSize;

    public boolean limit() {
        long now = System.currentTimeMillis();
        nowSize = Math.max(0, (nowSize - (now - time) * rate));
        time = now;
        if ((nowSize + 1) < total) {
            nowSize++;
            return true;
        } else {
            return false;
        }

    }
}

（4）Token Bucket 令牌桶

实现方式：规定固定容量的桶，token 以固定速度往桶内填充，当桶满时 token 不会被继续放入，每过来一个请求把 token 从桶中移除，如果桶中没有 token 不能请求。

public class TokenBucket {
    /**
     * 时间
     */
    private long time;
    /**
     * 总量
     */
    private Double total;
    /**
     * token 放入速度
     */
    private Double rate;
    /**
     * 当前总量
     */
    private Double nowSize;

    public boolean limit() {
        long now = System.currentTimeMillis();
        nowSize = Math.min(total, nowSize + (now - time) * rate);
        time = now;
        if (nowSize < 1) {
            // 桶里没有token
            return false;
        } else {
            // 存在token
            nowSize -= 1;
            return true;
        }
    }
}

3.分布式服务限流(dubbo限流)

Dubbo服务限流方式：
为了防止某个消费者的QPS或是所有消费者的QPS总和突然飙升而导致的重要服务的失效，系统可以对访问流量进行控制，这种对集群的保护措施称为服务限流。
Dubbo有多种限流方式，可以使用以下参数进行多维度的限流:
（1）accepts：服务端最大可接受连接数，可以理解为可以接受的最大消费者数；
（2）connections：每个Reference开启的连接数；
（3）actives：消费端控制每个接口的最大并发数；
（4）executes：服务端控制每个接口的最大并发数；

Dubbo服务限流方式具体使用：
（1）accepts的配置：
accepts配置数表示服务端配置最大可接受连接数，这是项目级别设置，它仅可设置在服务端。
比如一个Provider设置了accepts=2，该Provider3个消费者分别为C1、C2、C3。假如这3个消费者的启动顺序为C1、C2、C3，则C3会无法启动，因为服务已经达到了最大连接数限制；
基于XML配置如下：

<!--限制当前提供者在使用dubbo协议最多接受10个消费者链接-->
<dubbo:protocol name="dubbo" port="20880" accepts="10"/>

（2）connections的配置：
connections配置数表示每个Reference开启的长连接数，默认是0，表示所有的Reference共享同一条连接；如果大于0，则单独为此Reference设置connections条长连接。
比如同一个项目有3个reference:
@Reference(connections=3) HelloService helloService;
@Reference TestService testService;
@Reference FooService fooService;
则该项目会生成4条连接，其中helloService有3条，testService与fooService共用一条

connections可以设置在提供者端，也可以设置在消费者端。限定连接的个数。对于短连接，该属性效果与actives相同。但对于长连接，其限制的是长连接的个数。 一般情况下，会使connectons与actives联用，让connections限制长连接个数，让actives限制一个长连接中可以处理的请求个数。联用前提：使用默认的Dubbo服务暴露协议

服务提供端限流配置：
接口级别：

<!--限制当前接口中每个方法的链接数不能超过10个-->
<dubbo:service interface="com.tdd.service.UserService" ref="userService" connections="10"/>

方法级别：

<!--限制当前接口中sayHello方法的链接数不能超过10个-->
    <dubbo:service version="1.0" interface="com.tdd.service.UserService" ref="userService">
        <dubbo:method name="sayHello" connections="10"/>
    </dubbo:service>

服务消费端限流配置：
接口级别：

<!--设置当前消费者对指定接口的每一个方法的链接数不能超过10个-->
<dubbo:reference interface="com.tdd.service.UserService" id="userService" connections="10"/>

方法级别：

<!--设置当前消费者对指定接口的sayHello方法的链接数不能超过10个-->
<dubbo:reference interface="com.tdd.service.UserService" id="userService" connections="10">
        <dubbo:method name="sayHello" connections="10"/>
</dubbo:reference>

（3）actives的配置：
actives配置数表示服务消费端每个接口的最大并发数，默认是0，如果是0则没有限制。该限流方式可以设置在服务供者端，也可以设置在服务消费端。可以设置为接口级别，也可以设置为方法级别。
服务提供端限流配置：
接口级别：

<!--设置当前服务提供端对指定接口的每一个方法的并发连接数不能超过10个-->
<dubbo:service interface="com.tdd.service.UserService" ref="userService" actives="10"/>

方法级别：

<!--限制当前接口中sayHello方法的并发链接数不能超过10个-->
    <dubbo:service interface="com.tdd.service.UserService" ref="userService">
        <dubbo:method name="sayHello" actives="10"/>
    </dubbo:service>

服务消费端限流配置：
接口级别：

<!--设置当前消费者对指定接口的每一个方法的并发链接数不能超过10个-->
<dubbo:reference interface="com.tdd.service.UserService" id="userService" actives="10"/>

方法级别：

<!--设置当前消费者对指定接口的sayHello方法的并发链接数不能超过10个-->
    <dubbo:reference interface="com.tdd.service.UserService" id="userService" connections="10">
        <dubbo:method name="sayHello" actives="10"/>
    </dubbo:reference>

（4）executes的配置：
executes的配置数表示服务提供端每个接口的最大并发数，默认是0，如果是0则没有限制。它仅可设置在服务端。
基于XML配置如下：
接口级别：

<!--服务器端并发执行（或占用线程池线程数）不能超过 10 个-->
<dubbo:service interface="com.tdd.service.UserService" ref="userService" executes="10"/>

方法级别：

<!--服务器端并发执行（或占用线程池线程数）不能超过 10 个-->
<dubbo:service interface="com.tdd.service.UserService" ref="userService">
	<dubbo:method name="sayHello" executes="10"/>
</dubbo:service>

4.微服务限流(springcloud gateway和sentinel)

（1）springcloud gateway

springcloud gateway 默认使用redis进行限流，一般只要修改参数属性即可使用。

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

spring:
  cloud:
    gateway:
      routes:

      - id: requestratelimiter_route

        uri: lb://pigx-upms
        order: 10000
        predicates:

        - Path=/admin/**

       filters:
       - name: RequestRateLimiter
         args:
           redis-rate-limiter.replenishRate: 1  # 令牌桶的容积
           redis-rate-limiter.burstCapacity: 3  # 流速 每秒
           key-resolver: "#{@remoteAddrKeyResolver}" #SPEL表达式去的对应的bean
       - StripPrefix=1

@Bean
KeyResolver remoteAddrKeyResolver() {
    return exchange -> Mono.just(exchange.getRequest().getRemoteAddress().getHostName());
}

（2）sentinel

对于使用springcloud alibaba的项目可以使用sentinel来实现流控。即通过配置来控制每个url的流量。

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

spring:
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    sentinel:
      transport:
        dashboard: localhost:8080
        port: 8720
      datasource:
        ds:
          nacos:
            server-addr: localhost:8848
            dataId: spring-cloud-sentinel-nacos
            groupId: DEFAULT_GROUP
            rule-type: flow
            namespace: xxxxxxxx

在sentinel控制台进行流控设置：

• 资源名(resource)：限流规则的作用对象。
  -针对来源(limitApp)：流控针对的调用来源，若为 default 则不区分调用来源。
• 阈值类型(grade)：限流阈值类型，QPS 或线程数模式，0代表根据并发数量来限流，1代表根据QPS来进行流量控制。
• 单机阈值(count)：限流阈值
• 资源类型(strategy)：判断的根据是资源自身，还是根据其它关联资源 (refResource)，还是根据链路入口
• 流控效果(controlBehavior)：流控效果包括直接拒绝、排队等待、慢启动模式；
• 是否集群(clusterMode)：是否为集群模式

5.服务限流总结

若服务中使用了dubbo，则可以通过配置dubbo的服务提供者和服务消费者的处理请求数、发送请求数来进行服务限流；
spring cloud gateway和sentinel作为限流框架来使用都很好，若项目中使用了springcloud netflix 的一套组件，这里就可以选用spring cloud gateway来实现限流控制，若项目中接入了spring-cloud-alibaba的一套组件，比如nacos等，这样使用setinel进行流量控制会有更加好的体验。

---

文章内容输出来源：拉勾教育Java高薪训练营
若有错误之处，欢迎留言指正~~~