zoukankan      html  css  js  c++  java
  • 微言限流

    在系统架构设计当中,限流是一个不得不说的话题,因为他太不起眼,但是也太重要了。这点有些像古代镇守边陲的将士,据守隘口,抵挡住外族的千军万马,一旦隘口失守,各种饕餮涌入城内,势必将我们苦心经营的朝堂庙店洗劫一空,之前的所有努力都付之一炬。所以今天我们点了这个话题,一方面是要对限流做下总结,另一方面,抛砖引玉,看看大家各自的系统中,限流是怎么做的。

    提到限流,映入脑海的肯定是限制流量四个字,其重点在于如何限。而且这个限,还分为单机限和分布式限,单机限流,顾名思义,就是对部署了应用的docker机或者物理机,进行流量控制,以使得流量的涌入呈现可控的态势,防止过大过快的流量涌入造成应用的性能问题,甚至于失去响应。分布式限流,则是对集群的流量限制,一般这类应用的流量限制集中在一个地方来进行,比如redis,zk或者其他的能够支持分布式限流的组件中。这样当流量过大过快的时候,不至于因为集群中的一台机器被压垮而带来雪崩效应,造成集群应用整体坍塌。

    下面我们来细数一下各种限流操作。

    1. 基于计数器的单机限流

    此类限流,一般是通过应用中的计数器来进行流量限制操作。计数器可以用Integer类型的变量,也可以用Java自带的AtomicLong来实现。原理就是设置一个计数器的阈值,每当有流量进入的时候,将计数器递增,当达到阈值的时候,后续的请求将会直接被抛弃。代码实现如下:

        //限流计数器
        private static AtomicLong counter = new AtomicLong();
        //限流阈值
        private static final long counterMax = 500;
        //业务处理方法
        public void invoke(Request request) {
            try {
                //请求过滤
                if (counter.incrementAndGet() > counterMax) {
                    return;
                }
                //业务逻辑
                doBusiness(request);
            } catch (Exception e) {
                //错误处理
                doException(request,e);
            } finally {
                counter.decrementAndGet();
            }
        }

    上面的代码就是一个简单的基于计数器实现的单机限流。代码简单易行,操作方便,而且可以带来不错的效果。但是缺点也很明显,那就是先来的流量一般都能打进来,后来的流量基本上都会被拒绝。由于每个请求被执行的概率其实不一样,所以就没有公平性可言。

    所以总结一下此种限流优缺点:

    优点:代码简洁,操作方便

    缺点:先到先得,先到的请求可执行概率为100%,后到的请求可执行概率小一些,每个请求获得执行的机会是不平等的。

    那么,如果想让每个请求获得执行的机会是平等的话,该怎么做呢?

    2. 基于随机数的单机限流

    此种限流算法,使得请求可被执行的概率是一致的,所以相对于基于计数器实现的限流说来,对用户更加的友好一些。代码如下:

        //获取随机数
        private static ThreadLocalRandom ptgGenerator = ThreadLocalRandom.current();
        //限流百分比,允许多少流量通过此业务,这里限定为10%
        private static final long ptgGuarder = 10;
        //业务处理方法
        public void invoke(Request request) {
            try {
                //请求进入,获取百分比
                int currentPercentage = ptgGenerator.nextInt(1, 100);
                if (currentPercentage <= ptgGuarder) {
                    //业务处理
                    doBusiness(request);
                } else {
                    return;
                }
            } catch (Exception e) {
                //错误处理
                doException(request, e);
            }
        }

    从上面代码可以看出来,针对每个请求,都会先获取一个随机的1~100的执行率,然后和当前限流阈值(比如当前接口只允许10%的流量通过)相比,如果小于此限流阈值,则放行;如果大于此限流阈值,则直接返回,不做任何处理。和之前的计数器限流比起来,每个请求获得执行的概率是一致的。当然,在真正的业务场景中,用户可以通过动态配置化阈值参数,来控制每分钟通过的流量百分比,或者是每小时通过的流量百分比。但是如果对于突增的高流量,此种方法则有点问题,因为高并发下,每个请求之间进入的时间很短暂,导致nextInt生成的值,大概率是重复的,所以这里需要做的一个优化点,就是为其寻找合适的seed,用于优化nextInt生成的值。

    优点:代码简洁,操作简便,每个请求可执行的机会是平等的。

    缺点:不适合应用突增的流量。

    3. 基于时间段的单机限流

    有时候,我们的应用只想在单位时间内放固定的流量进来,比如一秒钟内只允许放进来100个请求,其他的请求抛弃。那么这里的做法有很多,可以基于计数器限流实现,然后判断时间,但是此种做法稍显复杂,可控性不是特别好。

    那么这里我们就要用到缓存组件来实现了。原理是这样的,首先请求进来,在guava中设置一个key,此key就是当前的秒数,秒数的值就是放进来的请求累加数,如果此累加数到100了,则拒绝后续请求即可。代码如下:

       //获取guava实例
        private static LoadingCache<Long, AtomicLong> guava = CacheBuilder.newBuilder()
                .expireAfterWrite(5, TimeUnit.SECONDS)
                .build(new CacheLoader<Long, AtomicLong>() {
                            @Override
                            public AtomicLong load(Long seconds) throws Exception {
                                return null;
                            }
                        });
        //每秒允许通过的请求数
        private static final long requestsPerSecond = 100;
        //业务处理方法
        public void invoke(Request request) {
            try {
                //guava key
                long guavaKey = System.currentTimeMillis() / 1000;
                //请求累加数
                long guavaVal = guava.get(guavaKey).incrementAndGet();
                if (guavaVal <= requestsPerSecond) {
                    //业务处理
                    doBusiness(request);
                } else {
                    return;
                }
            } catch (Exception e) {
                //错误处理
                doException(request, e);
            }
        }

    从上面的代码中可以看到,我们巧妙的利用了缓存组件的特性来实现。每当有请求进来,缓存组件中的key值累加,到达阈值则拒绝后续请求,这样很方便的实现了时间段限流的效果。虽然例子中给的是按照秒来限流的实现,我们可以在此基础上更改为按照分钟或者按照小时来实现的方案。

    优点:操作简单,可靠性强

    缺点:突增的流量,会导致每个请求都会访问guava,由于guava是堆内内存实现,势必会对性能有一点点影响。其实如果怕限流影响到其他内存计算,我们可以将此限流操作用堆外内存组件来实现,比如利用OHC或者mapdb等。也是比较好的备选方案。

    4. 基于漏桶算法的单机限流

    所谓漏桶(Leaky bucket),则是指,有一个盛水的池子,然后有一个进水口,有一个出水口,进水口的水流可大可小,但是出水口的水流是恒定的。下图图示可以显示的更加清晰:

    image

    从图中我们可以看到,水龙头相当于各端的流量,进入到漏桶中,当流量很小的时候,漏桶可以承载这种流量,出水口按照恒定的速度出水,水不会溢出来。当流量开始增大的时候,漏桶中的出水速度赶不上进水速度,那么漏桶中的水位一直在上涨。当流量再大,则漏桶中的水过满则溢。

    由于目前很多MQ,比如rabbitmq等,都属于漏桶算法原理的具体实现,请求过来先入queue队列,队列满了抛弃多余请求,之后consumer端匀速消费队列里面的数据。所以这里不再贴多余的代码。

    优点:流量控制效果不错

    缺点:不能够很好的应付突增的流量。适合保护性能较弱的系统,但是不适合性能较强的系统。如果性能较强的系统能够应对这种突增的流量的话,那么漏桶算法是不合适的。

    5. 基于令牌桶算法的单机限流

    所谓令牌桶(Token Bucket),则是指,请求过来的时候,先去令牌桶里面申请令牌,申请到令牌之后,才能去进行业务处理。如果没有申请到令牌,则操作终止。具体说明如下图:

    image

    由于生成令牌的流量是恒定的,面对突增流量的时候,桶里有足够令牌的情况下,突增流量可以快速的获取到令牌,然后进行处理。从这里可以看出令牌桶对于突增流量的处理是容许的。

    由于目前guava组件中已经有了对令牌桶的具体实现类:RateLimiter, 所以我们可以借助此类来实现我们的令牌桶限流。代码如下:

        //指定每秒放1个令牌
        private static RateLimiter limiter = RateLimiter.create(1);
        //令牌获取超时时间
        private static final long acquireTimeout = 1000;
        //业务处理方法
        public void invoke(Request request) {
            try {
                //拿到令牌则进行业务处理
                if (limiter.tryAcquire(acquireTimeout, TimeUnit.MILLISECONDS)) {
                    //业务处理
                    doBusiness(request);
                }
                //拿不到令牌则退出
                else {
                    return;
                }
            } catch (Exception e) {
                //错误处理
                doException(request, e);
            }
        }

    从上面代码我们可以看到,一秒生成一个令牌,那么我们的接口限定为一秒处理一个请求,如果感觉接口性能可以达到1000tps单机,那么我们可以适当的放大令牌桶中的令牌数量,比如800,那么当突增流量过来,会直接拿到令牌然后进行业务处理。但是当令牌桶中的令牌消费完毕之后,那么请求就会被阻塞,直到下一秒另一批800个令牌生成出来,请求才开始继续进行处理。

    所以利用令牌桶的优缺点就很明显了:

    有点:使用简单,有成熟组件

    缺点:适合单机限流,不适合分布式限流。

    6. 基于redis lua的分布式限流

    由于上面5中限流方式都是单机限流,但是在实际应用中,很多时候我们不仅要做单机限流,还要做分布式限流操作。由于目前做分布式限流的方法非常多,我就不再一一赘述了。我们今天用到的分布式限流方法,是redis+lua来实现的。

    为什么用redis+lua来实现呢?原因有两个:

    其一:redis的性能很好,处理能力强,且容灾能力也不错。

    其二:一个lua脚本在redis中就是一个原子性操作,可以保证数据的正确性。

    由于要做限流,那么肯定有key来记录限流的累加数,此key可以随着时间进行任意变动。而且key需要设置过期参数,防止无效数据过多而导致redis性能问题。

    来看看lua代码:

                --限流的key
                local key = 'limitkey'..KEYS[1]
    
                --累加请求数
                local val = tonumber(redis.call('get', key) or 0)
    
                --限流阈值
                local threshold = tonumber(ARGV[1])
    
                if  val>threshold then
                    --请求被限
                    return 0
                else
                    --递增请求数
                    redis.call('INCRBY', key, "1")
                    --5秒后过期
                    redis.call('expire', key, 5)
                    --请求通过
                    return 1
                end

    之后就是直接调用使用,然后根据返回内容为0还是1来判定业务逻辑能不能走下去就行了。这样可以通过此代码段来控制整个集群的流量,从而避免出现雪崩效应。当然此方案的解决方式也可以利用zk来进行,由于zk的强一致性保证,不失为另一种好的解决方案,但是由于zk的性能没有redis好,所以如果在意性能的话,还是用redis吧。

    优点:集群整体流量控制,防止雪崩效应

    缺点:需要引入额外的redis组件,且要求redis支持lua脚本。

    总结

    通过以上6种限流方式的讲解,主要是想起到抛砖引玉的作用,期待大家更好更优的解决方法。

    以上代码都是伪代码,使用的时候请进行线上验证,否则带来了副作用的话,就得不偿失了。

  • 相关阅读:
    libevent源码学习之event
    游戏寻路A*算法
    游戏地图动态生成
    一个基于protocol buffer的RPC实现
    TCMalloc源码学习(四)(小内存块释放)
    TCMalloc源码学习(三)(小块内存分配)
    TCMalloc源码学习(二)
    第五十四篇 Linux相关——远程连接SSH
    第五十三篇 Linux相关——Web服务器
    第五十二篇 Linux相关——数据库服务MySQL
  • 原文地址:https://www.cnblogs.com/scy251147/p/9865099.html
Copyright © 2011-2022 走看看