高并发的三把利器：缓存、限流、降级

た入场券 2021-09-23 05:32 376阅读 0赞

**缓存，降级和限流是大型分布式系统中的三把利剑。目前限流主要有漏桶和令牌桶两种算法。**

1.  **缓存** ：缓存的目的是减少外部调用，提高系统响速度。俗话说："缓存是网站优化第一定律"。缓存又分为本机缓存和分布式缓存，本机缓存是针对当前JVM实例的缓存，可以直接使用JDK Collection框架里面的集合类或者诸如Google Guava Cache来做本地缓存；分布式缓存目前主要有Memcached,Redis等。
2.  **降级** ：所谓降级是指在系统调用高峰时，优先保证我们的核心服务，对于非核心服务可以选择将其关闭以保证核心服务的可用。例如在淘宝双11时，支付功能是核心，其他诸如用户中心等非核心功能可以选择降级，优先保证交易。
3.  **限流** ：任何系统的性能都有一个上限，当并发量超过这个上限之后，可能会对系统造成毁灭性地打击。因此在任何时刻我们都必须保证系统的并发请求数量不能超过某个阈值，限流就是为了完成这一目的。

**相关术语：PV，UV，吞吐量（TPS）、QPS、并发数、响应时间（RT）**

1.  PV: page view 页面总访问量，每刷新一次记录一次。
2.  UV: unique view 客户端主机访问，指一天内相同IP的访问记为1次。
3.  响应时间(RT，Response Time)  
    　　 **响应时间是指系统对请求作出响应的时间，即每次请求的响应时间,直接决定用户体验性** 。直观上看，这个指标与人对软件性能的主观感受是非常一致的，因为它完整地记录了整个计算机系统处理请求的时间。由于一个系统通常会提供许多功能，而不同功能的处理逻辑也千差万别，因而不同功能的响应时间也不尽相同，甚至同一功能在不同输入数据的情况下响应时间也不相同。所以，在讨论一个系统的响应时间时，人们通常是指该系统所有功能的平均时间或者所有功能的最大响应时间。当然，往往也需要对每个或每组功能讨论其平均响应时间和最大响应时间。 　　对于单机的没有并发操作的应用系统而言，人们普遍认为响应时间是一个合理且准确的性能指标。需要指出的是，响应时间的绝对值并不能直接反映软件的性能的高低，软件性能的高低实际上取决于用户对该响应时间的接受程度。对于一个游戏软件来说，响应时间小于100毫秒应该是不错的，响应时间在1秒左右可能属于勉强可以接受，如果响应时间达到3秒就完全难以接受了。而对于编译系统来说，完整编译一个较大规模软件的源代码可能需要几十分钟甚至更长时间，但这些响应时间对于用户来说都是可以接受的。
4.  吞吐量(Throughput，TPS)  
    　　 **吞吐量是指系统在单位时间内处理请求的数量** 。对于无并发的应用系统而言，吞吐量与响应时间成严格的反比关系，实际上此时吞吐量就是响应时间的倒数。前面已经说过，对于单用户的系统，响应时间（或者系统响应时间和应用延迟时间）可以很好地度量系统的性能，但对于并发系统，通常需要用吞吐量作为性能指标。 　　对于一个多用户的系统，如果只有一个用户使用时系统的平均响应时间是t，当有你n个用户使用时，每个用户看到的响应时间通常并不是n×t，而往往比n×t小很多（当然，在某些特殊情况下也可能比n×t大，甚至大很多）。这是因为处理每个请求需要用到很多资源，由于每个请求的处理过程中有许多不走难以并发执行，这导致在具体的一个时间点，所占资源往往并不多。也就是说在处理单个请求时，在每个时间点都可能有许多资源被闲置，当处理多个请求时，如果资源配置合理，每个用户看到的平均响应时间并不随用户数的增加而线性增加。实际上，不同系统的平均响应时间随用户数增加而增长的速度也不大相同，这也是采用吞吐量来度量并发系统的性能的主要原因。一般而言，吞吐量是一个比较通用的指标，两个具有不同用户数和用户使用模式的系统，如果其最大吞吐量基本一致，则可以判断两个系统的处理能力基本一致。
5.  并发用户数  
    　　并发用户数是指系统可以同时承载的正常使用系统功能的用户的数量。与吞吐量相比，并发用户数是一个更直观但也更笼统的性能指标。实际上，并发用户数是一个非常不准确的指标，因为用户不同的使用模式会导致不同用户在单位时间发出不同数量的请求。一网站系统为例，假设用户只有注册后才能使用，但注册用户并不是每时每刻都在使用该网站，因此具体一个时刻只有部分注册用户同时在线，在线用户就在浏览网站时会花很多时间阅读网站上的信息，因而具体一个时刻只有部分在线用户同时向系统发出请求。这样，对于网站系统我们会有三个关于用户数的统计数字：注册用户数、在线用户数和同时发请求用户数。由于注册用户可能长时间不登陆网站，使用注册用户数作为性能指标会造成很大的误差。而在线用户数和同事发请求用户数都可以作为性能指标。相比而言，以在线用户作为性能指标更直观些，而以同时发请求用户数作为性能指标更准确些。
6.  QPS每秒查询率(Query Per Second)  
    　　QPS: query per second,即每秒访问量，QPS很大程度上代表了系统的繁忙度，没次请求可能存在多次的磁盘io，网络请求，多个cpu时间片，一旦qps超过了预先设置的阀值，可以考量扩容增加服务器，避免访问量过大导致的宕机。每秒查询率QPS是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准，在因特网上，作为域名系统服务器的机器的性能经常用每秒查询率来衡量。对应fetches/sec，即每秒的响应请求数，也即是最大吞吐能力。 （看来是类似于TPS，只是应用于特定场景的吞吐量） 。
    
    **原理** ：  
    每天80%的访问集中在20%的时间里，这20%时间叫做峰值时间。 公式：( 总PV数 \* 80% ) / ( 每天秒数 \* 20% ) = 峰值时间每秒请求数(QPS) 。 机器：峰值时间每秒QPS / 单台机器的QPS = 需要的机器 。 每天300w PV 的在单台机器上，这台机器需要多少QPS？ ( 3000000 \* 0.8 ) / (86400 \* 0.2 ) = 139 (QPS)。 一般需要达到139QPS，因为是峰值。

--------------------

## 1、缓存（待补充） ##

## 2、限流 ##

### 2.1 应用级别限流 ###

2.1.1限流总并发/连接/请求数

对于一个应用系统来说一定会有极限并发/请求数，即总有一个TPS/QPS阀值，如果超了阀值则系统就会不响应用户请求或响应的非常慢，因此我们最好进行过载保护，防止大量请求涌入击垮系统。 如果你使用过Tomcat，其Connector 其中一种配置有如下几个参数：

*  acceptCount：如果Tomcat的线程都忙于响应，新来的连接会进入队列排队，如果超出排队大小，则拒绝连接；
 *  maxConnections： 瞬时最大连接数，超出的会排队等待；
 *  maxThreads：Tomcat能启动用来处理请求的最大线程数，如果请求处理量一直远远大于最大线程数则可能会僵死。

详细的配置请参考官方文档。另外如Mysql（如max\_connections）、Redis（如tcp-backlog）都会有类似的限制连接数的配置。

2.1.2 限流总资源数

如果有的资源是稀缺资源（如数据库连接、线程），而且可能有多个系统都会去使用它，那么需要限制应用；可以使用池化技术来限制总资源数：连接池、线程池。比如分配给每个应用的数据库连接是100，那么本应用最多可以使用100个资源，超出了可以等待或者抛异常。

2.1.3 限流某个接口的总并发/请求数

如果接口可能会有突发访问情况，但又担心访问量太大造成崩溃，如抢购业务；这个时候就需要限制这个接口的总并发/请求数总请求数了；因为粒度比较细，可以为每个接口都设置相应的阀值。可以使用Java中的AtomicLong进行限流：

try {
        if(atomic.incrementAndGet() > 限流数) {
            //拒绝请求
       }
        //处理请求
    } finally {
        atomic.decrementAndGet();
    }

适合对业务无损的服务或者需要过载保护的服务进行限流，如抢购业务，超出了大小要么让用户排队，要么告诉用户没货了，对用户来说是可以接受的。而一些开放平台也会限制用户调用某个接口的试用请求量，也可以用这种计数器方式实现。这种方式也是简单粗暴的限流，没有平滑处理，需要根据实际情况选择使用；

2.1.4限流某个接口的时间窗请求数

即一个时间窗口内的请求数，如想限制某个接口/服务每秒/每分钟/每天的请求数/调用量。如一些基础服务会被很多其他系统调用，比如商品详情页服务会调用基础商品服务调用，但是怕因为更新量比较大将基础服务打挂，这时我们要对每秒/每分钟的调用量进行限速；一种实现方式如下所示：

LoadingCache<Long, AtomicLong> counter =
            CacheBuilder.newBuilder()
                    .expireAfterWrite(2, TimeUnit.SECONDS)
                    .build(new CacheLoader<Long, AtomicLong>() {
                        @Override
                        public AtomicLong load(Long seconds) throws Exception {
                            return new AtomicLong(0);
                        }
                    });
    long limit = 1000;
    while(true) {
        //得到当前秒
        long currentSeconds = System.currentTimeMillis() / 1000;
        if(counter.get(currentSeconds).incrementAndGet() > limit) {
            System.out.println("限流了:" + currentSeconds);
            continue;
        }
        //业务处理
    }

我们使用Guava的Cache来存储计数器，过期时间设置为2秒（保证1秒内的计数器是有的），然后我们获取当前时间戳然后取秒数来作为KEY进行计数统计和限流，这种方式也是简单粗暴，刚才说的场景够用了。

2.1.5 平滑限流某个接口的请求数

之前的限流方式都不能很好地应对突发请求，即瞬间请求可能都被允许从而导致一些问题；因此在一些场景中需要对突发请求进行整形，整形为平均速率请求处理（比如5r/s，则每隔200毫秒处理一个请求，平滑了速率）。这个时候有两种算法满足我们的场景：令牌桶和漏桶算法。Guava框架提供了令牌桶算法实现，可直接拿来使用。

Guava RateLimiter提供了令牌桶算法实现：平滑突发限流(SmoothBursty)和平滑预热限流(SmoothWarmingUp)实现。

**Note:**  
到此应用级限流的一些方法就介绍完了。假设将应用部署到多台机器， **应用级限流方式只是单应用内的请求限流 ，不能进行全局限流** 。因此我们需要分布式限流和接入层限流来解决这个问题。

### 2.2 分布式限流 ###

分布式限流最关键的是要将限流服务做成原子化，而解决方案可以使使用redis+lua或者nginx+lua技术进行实现，通过这两种技术可以实现的高并发和高性能。

### 2.3 方案 ###

2.3.1 自定义注解+AOP的方式实现(适用于单体应用)

**示例代码如下** ：

*  自定义注解

import java.lang.annotation.*;
     
    /**
     * 自定义注解可以不包含属性，成为一个标识注解
     */
    @Inherited
    @Documented
    @Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface RateLimitAspect {
       
    }

*  自定义切面类

import com.google.common.util.concurrent.RateLimiter;
    import com.test.cn.springbootdemo.util.ResultUtil;
    import net.sf.json.JSONObject;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Scope;
    import org.springframework.stereotype.Component;
     
    import javax.servlet.ServletOutputStream;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
     
    @Component
    @Scope
    @Aspect
    public class RateLimitAop {
     
        @Autowired
        private HttpServletResponse response;
        //比如说，我这里设置"并发数"为5
        private RateLimiter rateLimiter = RateLimiter.create(5.0); 
     
        @Pointcut("@annotation(com.test.cn.springbootdemo.aspect.RateLimitAspect)")
        public void serviceLimit() {
     
        }
     
        @Around("serviceLimit()")
        public Object around(ProceedingJoinPoint joinPoint) {
            Boolean flag = rateLimiter.tryAcquire();
            Object obj = null;
            try {
                if (flag) {
                    obj = joinPoint.proceed();
                }else{
                    String result = JSONObject.fromObject(ResultUtil.success1(100, "failure")).toString();
                    output(response, result);
                }
            } catch (Throwable e) {
                e.printStackTrace();
            }
            System.out.println("flag=" + flag + ",obj=" + obj);
            return obj;
        }
        
        public void output(HttpServletResponse response, String msg) throws IOException {
            response.setContentType("application/json;charset=UTF-8");
            ServletOutputStream outputStream = null;
            try {
                outputStream = response.getOutputStream();
                outputStream.write(msg.getBytes("UTF-8"));
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                outputStream.flush();
                outputStream.close();
            }
        }
    }

*  测试controller

import com.test.cn.springbootdemo.aspect.RateLimitAspect;
    import com.test.cn.springbootdemo.util.ResultUtil;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
     
     
    @Controller
    public class TestController {
     
        @ResponseBody
        @RateLimitAspect
        @RequestMapping("/test")
        public String test(){
            return ResultUtil.success1(1001, "success").toString();
        }

2.3.2 自定义注解+拦截器+Redis实现限流 (单体和分布式均适用，全局限流)

**示例代码如下** ：

*  自定义注解

@Inherited
    @Documented
    @Target({ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface AccessLimit {
     
        int limit() default 5;  
     
        int sec() default 5;
    }

*  拦截器

@Component
    public class AccessLimitInterceptor implements HandlerInterceptor {
     
        @Autowired
        private RedisTemplate<String, Integer> redisTemplate;  //使用RedisTemplate操作redis
     
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            if (handler instanceof HandlerMethod) {
                HandlerMethod handlerMethod = (HandlerMethod) handler;
                Method method = handlerMethod.getMethod();
                if (!method.isAnnotationPresent(AccessLimit.class)) {
                    return true;
                }
                AccessLimit accessLimit = method.getAnnotation(AccessLimit.class);
                if (accessLimit == null) {
                    return true;
                }
                int limit = accessLimit.limit();
                int sec = accessLimit.sec();
                String key = IPUtil.getIpAddr(request) + request.getRequestURI();
                Integer maxLimit = redisTemplate.opsForValue().get(key);
                if (maxLimit == null) {
                    redisTemplate.opsForValue().set(key, 1, sec, TimeUnit.SECONDS);  //set时一定要加过期时间
                } else if (maxLimit < limit) {
                    redisTemplate.opsForValue().set(key, maxLimit + 1, sec, TimeUnit.SECONDS);
                } else {
                    output(response, "请求太频繁!");
                    return false;
                }
            }
            return true;
        }
     
        public void output(HttpServletResponse response, String msg) throws IOException {
            response.setContentType("application/json;charset=UTF-8");
            ServletOutputStream outputStream = null;
            try {
                outputStream = response.getOutputStream();
                outputStream.write(msg.getBytes("UTF-8"));
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                outputStream.flush();
                outputStream.close();
            }
        }
     
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
     
        }
     
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
     
        }
    }

*  controller

@Controller
    @RequestMapping("/activity")
    public class AopController {
        @ResponseBody
        @RequestMapping("/seckill")
        @AccessLimit(limit = 4,sec = 10)  //加上自定义注解即可
        public String test (HttpServletRequest request,@RequestParam(value = "username",required = false) String userName){
            //TODO somethings……
            return   "hello world !";
        }
    }

## 3、服务降级（待补充） ##

## 参考 ##

*  [Guava API文档][Guava API]
 *  [使用Guava RateLimiter限流以及源码解析][Guava RateLimiter]
 *  [阿里巴巴开源限流系Sentinel 全解][Sentinel]
 *  [syj-ratelimit 实现基于redis+lua 的无侵入式限流][syj-ratelimit _redis_lua]
 *  [https://blog.csdn.net/johnf\_nash/article/details/89791808][https_blog.csdn.net_johnf_nash_article_details_89791808]   其他微博大佬地址

[Guava API]: https://juejin.im/post/5c7510f3518825625e4ae41b
[Guava RateLimiter]: https://segmentfault.com/a/1190000016182737
[Sentinel]: https://juejin.im/post/5c26023151882545e24f2ed9
[syj-ratelimit _redis_lua]: https://github.com/shiyujun/syj-ratelimit
[https_blog.csdn.net_johnf_nash_article_details_89791808]: https://blog.csdn.net/johnf_nash/article/details/89791808