共计 5681 个字符，预计需要花费 15 分钟才能阅读完成。
我的公众号：MarkerHub，网站：https://markerhub.com
小 Hub 领读：
文中介绍了罕用的限流算法，如计数器、漏桶算法、令牌桶算法等，而后也介绍了 guava 工具应用、nginx 中间件部署等计划。应该是服务外面很罕用的伎俩的了。
- 作者：nick hao
- cnblogs.com/haoxinyue/p/6792309.html
开涛大神在博客中说过： 在开发高并发零碎时有三把利器用来爱护零碎： 缓存、降级和限流。 本文联合作者的一些教训介绍限流的相干概念、算法和惯例的实现形式。
缓存
缓存比拟好了解，在大型高并发零碎中，如果没有缓存数据库将分分钟被爆，零碎也会霎时瘫痪。
应用缓存不单单可能晋升零碎访问速度、进步并发访问量，也是爱护数据库、爱护零碎的无效形式。
大型网站个别次要是“读”，缓存的应用很容易被想到。在大型“写”零碎中，缓存也经常扮演者十分重要的角色。
比方累积一些数据批量写入，内存外面的缓存队列（生产生产），以及 HBase 写数据的机制等等也都是通过缓存晋升零碎的吞吐量或者实现零碎的保护措施。甚至消息中间件，你也能够认为是一种分布式的数据缓存。
降级
服务降级是当服务器压力剧增的状况下，依据以后业务状况及流量对一些服务和页面有策略的降级，以此开释服务器资源以保障外围工作的失常运行。
降级往往会指定不同的级别，面临不同的异样等级执行不同的解决。
依据服务形式：能够拒接服务，能够提早服务，也有时候能够随机服务。依据服务范畴：能够砍掉某个性能，也能够砍掉某些模块。
总之服务降级须要依据不同的业务需要采纳不同的降级策略。次要的目标就是服务尽管有损然而总比没有好。
限流
限流能够认为服务降级的一种，限流就是限度零碎的输出和输入流量已达到爱护零碎的目标。
一般来说零碎的吞吐量是能够被测算的，为了保证系统的稳固运行，一旦达到的须要限度的阈值，就须要限度流量并采取一些措施以实现限度流量的目标。比方：提早解决，回绝解决，或者局部回绝解决等等。
限流的算法
常见的限流算法有：计数器、漏桶和令牌桶算法。
计数器
计数器是最简略粗犷的算法。
比方某个服务最多只能每秒钟解决 100 个申请。咱们能够设置一个 1 秒钟的滑动窗口，窗口中有 10 个格子，每个格子 100 毫秒，每 100 毫秒挪动一次，每次挪动都须要记录以后服务申请的次数。
内存中须要保留 10 次的次数。能够用数据结构 LinkedList 来实现。格子每次挪动的时候判断一次，以后拜访次数和 LinkedList 中最初一个相差是否超过 100，如果超过就须要限流了。
很显著，当滑动窗口的格子划分的越多，那么滑动窗口的滚动就越平滑，限流的统计就会越准确。
示例代码如下：
// 服务拜访次数，能够放在 Redis 中，实现分布式系统的拜访计数
Long counter = 0L;
// 应用 LinkedList 来记录滑动窗口的 10 个格子。LinkedList<Long> ll = new LinkedList<Long>();
public static void main(String[] args)
{Counter counter = new Counter();
counter.doCheck();}
private void doCheck()
{while (true)
{ll.addLast(counter);
if (ll.size() > 10)
{ll.removeFirst();
}
// 比拟最初一个和第一个，两者相差一秒
if ((ll.peekLast() - ll.peekFirst()) > 100)
{//To limit rate}
Thread.sleep(100);
}
}
漏桶算法
漏桶算法即 leaky bucket 是一种十分罕用的限流算法，能够用来实现流量整形（Traffic Shaping）和流量管制（Traffic Policing）。
贴了一张维基百科上示意图帮忙大家了解：
漏桶算法的次要概念如下：
- 一个固定容量的漏桶，依照常量固定速率流出水滴；
- 如果桶是空的，则不需流出水滴；
- 能够以任意速率流入水滴到漏桶；
- 如果流入水滴超出了桶的容量，则流入的水滴溢出了（被抛弃），而漏桶容量是不变的。
漏桶算法比拟好实现，在单机零碎中能够应用队列来实现（.Net 中 TPL DataFlow 能够较好的解决相似的问题，你能够在这里找到相干的介绍），在分布式环境中消息中间件或者 Redis 都是可选的计划。
令牌桶算法
令牌桶算法是一个寄存固定容量令牌（token）的桶，依照固定速率往桶里增加令牌。
令牌桶算法根本能够用上面的几个概念来形容：
- 令牌将依照固定的速率被放入令牌桶中。比方每秒放 10 个。
- 桶中最多寄存 b 个令牌，当桶满时，新增加的令牌被抛弃或回绝。
- 当一个 n 个字节大小的数据包达到，将从桶中删除 n 个令牌，接着数据包被发送到网络上。
- 如果桶中的令牌有余 n 个，则不会删除令牌，且该数据包将被限流（要么抛弃，要么缓冲区期待）。
如下图：
令牌算法是依据放令牌的速率去管制输入的速率，也就是上图的 to network 的速率。to network 咱们能够了解为音讯的处理程序，执行某段业务或者调用某个 RPC。
漏桶和令牌桶的比拟
令牌桶能够在运行时管制和调整数据处理的速率，解决某时的突发流量。
放令牌的频率减少能够晋升整体数据处理的速度，而通过每次获取令牌的个数减少或者加快令牌的发放速度和升高整体数据处理速度。而漏桶不行，因为它的流出速率是固定的，程序处理速度也是固定的。
整体而言，令牌桶算法更优，然而实现更为简单一些。
限流算法实现
Guava
Guava 是一个 Google 开源我的项目，蕴含了若干被 Google 的 Java 我的项目宽泛依赖的外围库，其中的 RateLimiter 提供了令牌桶算法实现：平滑突发限流 (SmoothBursty) 和平滑预热限流 (SmoothWarmingUp) 实现。
1. 惯例速率：
创立一个限流器，设置每秒搁置的令牌数：2 个。返回的 RateLimiter 对象能够保障 1 秒内不会给超过 2 个令牌，并且是固定速率的搁置。
达到平滑输入的成果
public void test()
{
/**
* 创立一个限流器，设置每秒搁置的令牌数：2 个。速率是每秒能够 2 个的音讯。* 返回的 RateLimiter 对象能够保障 1 秒内不会给超过 2 个令牌，并且是固定速率的搁置。* 达到平滑输入的成果
*/
RateLimiter r = RateLimiter.create(2);
while (true)
{
/**
* acquire() 获取一个令牌，并且返回这个获取这个令牌所须要的工夫。* 如果桶里没有令牌则期待，直到有令牌。* acquire(N) 能够获取多个令牌。*/
System.out.println(r.acquire());
}
}
下面代码执行的后果如下图，根本是 0.5 秒一个数据。拿到令牌后能力解决数据，达到输入数据或者调用接口的平滑成果。
acquire() 的返回值是期待令牌的工夫，如果须要对某些突发的流量进行解决的话，能够对这个返回值设置一个阈值，依据不同的状况进行解决，比方过期抛弃。
2. 突发流量：
突发流量能够是突发的多，也能够是突发的少。首先来看个突发多的例子。还是下面例子的流量，每秒 2 个数据令牌。如下代码应用 acquire 办法，指定参数。
System.out.println(r.acquire(2));
System.out.println(r.acquire(1));
System.out.println(r.acquire(1));
System.out.println(r.acquire(1));
失去如下相似的输入。
如果要一次新解决更多的数据，则须要更多的令牌。代码首先获取 2 个令牌，那么下一个令牌就不是 0.5 秒之后取得了，还是 1 秒当前，之后又复原惯例速度。
这是一个突发多的例子，如果是突发没有流量，如下代码：
System.out.println(r.acquire(1));
Thread.sleep(2000);
System.out.println(r.acquire(1));
System.out.println(r.acquire(1));
System.out.println(r.acquire(1));
失去如下相似的后果：
等了两秒钟之后，令牌桶外面就积攒了 3 个令牌，能够间断不花工夫的获取进去。解决突发其实也就是在单位工夫内输入恒定。
这两种形式都是应用的 RateLimiter 的子类 SmoothBursty。另一个子类是 SmoothWarmingUp，它提供的有肯定缓冲的流量输入计划。
/**
* 创立一个限流器，设置每秒搁置的令牌数：2 个。速率是每秒能够 210 的音讯。* 返回的 RateLimiter 对象能够保障 1 秒内不会给超过 2 个令牌，并且是固定速率的搁置。* 达到平滑输入的成果
* 设置缓冲工夫为 3 秒
*/
RateLimiter r = RateLimiter.create(2,3,TimeUnit.SECONDS);
while (true) {
/**
* acquire() 获取一个令牌，并且返回这个获取这个令牌所须要的工夫。* 如果桶里没有令牌则期待，直到有令牌。* acquire(N) 能够获取多个令牌。*/
System.out.println(r.acquire(1));
System.out.println(r.acquire(1));
System.out.println(r.acquire(1));
System.out.println(r.acquire(1));
}
输入后果如下图，因为设置了缓冲的工夫是 3 秒，令牌桶一开始并不会 0.5 秒给一个音讯，而是造成一个平滑线性降落的坡度，频率越来越高，在 3 秒钟之内达到本来设置的频率，当前就以固定的频率输入。
图中红线圈进去的 3 次累加起来正好是 3 秒左右。这种性能适宜零碎刚启动须要一点工夫来“热身”的场景。
Nginx
对于 Nginx 接入层限流能够应用 Nginx 自带了两个模块：
- 连接数限流模块 ngx_http_limit_conn_module
- 漏桶算法实现的申请限流模块 ngx_http_limit_req_module
1. ngx_http_limit_conn_module
咱们常常会遇到这种状况，服务器流量异样，负载过大等等。
对于大流量歹意的攻打拜访，会带来带宽的节约，服务器压力，影响业务，往往思考对同一个 ip 的连接数，并发数进行限度。ngx_http_limit_conn_module 模块来实现该需要。
该模块能够依据定义的键来限度每个键值的连接数，如同一个 IP 起源的连接数。
并不是所有的连贯都会被该模块计数，只有那些正在被解决的申请（这些申请的头信息已被齐全读入）所在的连贯才会被计数。
咱们能够在 nginx_conf 的 http{} 中加上如下配置实现限度：
# 限度每个用户的并发连接数，取名 one
limit_conn_zone $binary_remote_addr zone=one:10m;
#配置记录被限流后的日志级别，默认 error 级别
limit_conn_log_level error;
#配置被限流后返回的状态码，默认返回 503
limit_conn_status 503;
而后在 server{} 里加上如下代码：
# 限度用户并发连接数为 1
limit_conn one 1;
而后咱们是应用 ab 测试来模仿并发申请：
ab -n 5 -c 5 http://10.23.22.239/index.html
失去上面的后果，很显著并发被限制住了，超过阈值的都显示 503：
另外方才是配置针对单个 IP 的并发限度，还是能够针对域名进行并发限度，配置和客户端 IP 相似。
#http{} 段配置
limit_conn_zone $ server_name zone=perserver:10m;
#server{} 段配置
limit_conn perserver 1;
2. ngx_http_limit_req_module
下面咱们应用到了 ngx_http_limit_conn_module 模块，来限度连接数。那么申请数的限度该怎么做呢？
这就须要通过 ngx_http_limit_req_module 模块来实现，该模块能够通过定义的键值来限度申请解决的频率。
特地的，能够限度来自单个 IP 地址的申请解决频率。限度的办法是应用了漏斗算法，每秒固定解决申请数，推延过多申请。
如果申请的频率超过了限度域配置的值，申请解决会被提早或被抛弃，所以所有的申请都是以定义的频率被解决的。
在 http{} 中配置
# 区域名称为 one，大小为 10m，均匀解决的申请频率不能超过每秒一次。limit_req_zone $binary_remote_addr zone=one:10m rate=1r/s;
在 server{} 中配置
# 设置每个 IP 桶的数量为 5
limit_req zone=one burst=5;
下面设置定义了每个 IP 的申请解决只能限度在每秒 1 个。并且服务端能够为每个 IP 缓存 5 个申请，如果操作了 5 个申请，申请就会被抛弃。
应用 ab 测试模仿客户端间断拜访 10 次：
ab -n 10 -c 10 http://10.23.22.239/index.html
如下图，设置了通的个数为 5 个。一共 10 个申请，第一个申请马上被解决。第 2-6 个被寄存在桶中。因为桶满了，没有设置 nodelay 因而，余下的 4 个申请被抛弃。
举荐浏览
太赞了，这个 Java 网站，什么我的项目都有！https://markerhub.com
这个 B 站的 UP 主，讲的 java 真不错！
太赞了！最新版 Java 编程思维能够在线看了！
