序言
他们每个控制系统在做银穗草的这时，都有两个处置最大值，当接近最大值竭尽全力接受允诺的这时，会导致整个控制系统积极响应较慢；为了为保护控制系统，须要婉拒处置网络连接的允诺，这就是他们上面介绍的开闭，通过预设两个最大值共振频率，管制允诺达到那个最大值，以来为保护控制系统；他们常用的许多开发工具比如说tomcat，mysql，redis等等都有类似的管制。
开闭演算法
做开闭的这时他们有许多常用的开闭演算法包括：计时器开闭，副本桶开闭，漏桶开闭；
1.副本桶开闭副本桶演算法的基本原理是控制系统以很大速度向桶中放进副本，清空了就弃置副本；允诺这时林美珠从桶中抽出副本，如果扁蛛到副本，则能竭尽全力完成允诺，否则等候或是DNS；副本桶容许很大程度突发性网络流量，如果有副本就可以处置，支持一次拿多个副本；
2.漏桶开闭漏桶演算法的基本原理是按照固定自变量速度流向允诺，流向允诺速度任一，当允诺数少于桶的耗电量时，捷伊允诺等候或是DNS；能窥见漏桶演算法能强制性管制数据的传输速率；
3.计数器开闭计时器是一种非常简单蛮横的演算法，主要用以管制总mammalian数，比如说资料库连接池、缓存池、直降的mammalian数；计时器开闭如果很大天数内的总允诺数少于预设的danger则展开开闭；
怎样开闭
了解了开闭演算法之后，他们须要知道在什么地方开闭，和怎样开闭；对两个控制系统来说他们常常能在网络连接层展开开闭，那个大部分情况下能间接采用nginx，OpenResty等开发工具间接处置；也能在销售业务层展开开闭，那个须要根据他们不同的销售业务需求采用相关的开闭演算法来处置。
销售业务层开闭
对销售业务层他们可能将是单结点的，也可能将是多结点使用者存取的，也可能将是多结点无存取的；这这时他们就要界定是民主化内的开闭却是须要分布式系统开闭。
民主化内开闭
对民主化内开闭相对而言却是非常简单的，guava是他们经常采用的法宝，上面分别看看怎样管制USB的总mammalian量，某一天数询问处的允诺数，和采用副本桶和漏桶演算法更加光滑的开闭；
管制USB的总mammalian量只须要配置两个总mammalian量，接着采用两个打印机历史记录每天允诺，接着和总mammalian量比较方可：
private static int max = 10;
private static AtomicInteger limiter = new AtomicInteger();
if (limiter.incrementAndGet() > max){
System.err.println(“少于最大管制数”);
return;
}
管制天数询问处允诺数管制某一USB在指定天数之内的允诺量，能采用guava的cache来缓存计时器，接着再设置过期天数；比如说上面设置每分钟最大允诺为100：
LoadingCache<Long, AtomicLong> counter = CacheBuilder.newBuilder().expireAfterWrite(1, TimeUnit.MINUTES).build(new CacheLoader<Long, AtomicLong>() {
@Override
public AtomicLong load(Long key) throws Exception {
return new AtomicLong(0);
}
});
private static int max = 100;
long curMinutes = System.currentTimeMillis() / 1000 * 60;
if (counter.get(curMinutes).incrementAndGet() > max) {
System.err.println(“天数询问处允诺数少于上限”);
return;
}
过期天数为一分钟，每分钟自动清零；这种处置方式可能将会出现超限的情况，比如说前59秒都没有消息，到60的这时一下子来了200条消息，这这时先接受了100条消息，刚好到期计时器清0，接着又接受了100条消息；这种情况能参考TCP的滑动询问处思路来解决。
光滑开闭允诺计时器的方式却是比较蛮横的，副本桶和漏桶开闭这两种演算法相对而言却是比较光滑的，能间接采用guava提供的RateLimiter类：
RateLimiter limiter = RateLimiter.create(2);
System.out.println(limiter.acquire(4));
System.out.println(limiter.acquire());
System.out.println(limiter.acquire());
System.out.println(limiter.acquire(2));
System.out.println(limiter.acquire());
System.out.println(limiter.acquire());
create(2)表示桶耗电量为2并且每秒新增2个副本，也就是500毫秒新增两个副本，acqui
0.0
1.998633
0.49644
0.500224
0.999335
0.500186
分布式系统开闭
现在大部分控制系统都采用了多结点部署，所以两个销售业务可能将在多个民主化内被处置，所以这这时分布式系统开闭必不可少，比如说常用的直降控制系统，可能将同时有N台销售业务逻辑结点；
常规的做法是采用Redis+lua和OpenResty+lua来实现，将开闭服务做成原子化，同时也要保证高性能；Redis和OpenResty都已高性能著称，同时也提供了原子化方案，具体如下所示：Redis+luaRedis在服务端对消息的处置是单缓存的，同时支持lua脚本的执行，能将开闭的相关逻辑用lua脚本实现，来保证原子性，大体实现如下：
— 开闭 key
local key = KEYS[1]
— 开闭大小
local limit = tonumber(ARGV[1])
— 过期天数
local expire = tonumber(ARGV[2])
local current = tonumber(redis.call(get,key) or “0”)
if current + 1 > limit then
return 0;
else
redis.call(“INCRBY”, key, 1)
redis.call(“EXPIRE”, key, expire)
return current + 1
end
以上采用计时器演算法来实现开闭，在调用lua的地方能传入开闭key，开闭大小和key的有效期；返回结果如果为0表示超出开闭大小，否则返回当前累计的值。
OpenResty+luaOpenResty核心就是nginx，但是在那个基础之上加了很多第三方模块，ngx_lua模块将lua嵌入到了nginx中，使得nginx能作为两个web服务器来采用；还有其他常用的开发模块如：lua-resty-lock，lua-resty-limit-traffic，lua-resty-memcached，lua-resty-mysql，lua-resty-redis等等；
本小节他们先采用lua-resty-lock模块来实现两个简单计时器开闭，相关lua代码如下：
local locks = require “resty.lock”;
local function acquire()
local lock = locks:new(“locks”);
local elapsed, err = local key = ngx.var.remote_addr;
–开闭大小
local limit = 5;
local current = limit_counter:get(key);
–打印key和当前值
ngx.say(“key=”..key..”,value=”..tostring(current));
if current ~= nil and current + 1 > limit then
lock:unlock();
return 0;
end
if current == nil then
limit_counter:set(key,1,5); –设置过期天数为5秒
else
limit_counter:incr(key,1);
end
lock:unlock();
return 1;
end
以上是两个对ip展开开闭的实例，因为须要保证原子性，所以采用了resty.lock模块，同时也类似redis设置了过期天数重置，另外一点须要注意对锁的释放；还须要设置两个共享字典：
http {
…
#lua_shared_dict <name> <size> 定义一块名为name的共享内存空间，内存大小为size; 通过该命令定义的共享内存对象对Nginx中所有worker民主化都是可见的
lua_shared_dict locks 10m;
lua_shared_dict limit_counter 10m;
}
网络连接层开闭
网络连接层通常就是网络流量入口处，Nginx被很多控制系统用作网络流量入口，当然OpenResty也不例外，而且OpenResty提供了更强大的功能，比如说这里将要介绍的lua-resty-limit-traffic模块，是两个功能强大的开闭模块；在采用lua-resty-limit-traffic之前他们先大致看一下怎样采用OpenResty；
OpenResty安装采用
下载安装配置间接去官方下载方可：http://openresty.org/en/download.html，启动，重载，停止命令如下：
nginx.exe
nginx.exe -s reload
nginx.exe -s stop
打开ip+端口，能看到：Welcome to OpenResty! 即表示启动成功；
lua脚本实例首先须要在nginx.conf的http目录下做如下配置：
http {
…
lua_package_path “/lualib/?.lua;;”; #lua 模块
lua_package_cpath “/lualib/?.so;;”; #c模块
include lua.conf; #导入自定义lua配置文件
}
这里自定义了两个lua.conf，有关lua的允诺都在这里面配置，放在和nginx.conf两个路径下方可；已两个test.lua为例，lua.conf配置如下：
#lua.conf
server {
charset utf-8; #设置编码
listen 8081;
server_name _;
location /test {
default_type text/html;
content_by_lua_file lua/api/test.lua;
}
这里把所有的lua文件都放在lua/api目录下，比如说两个最简单的hello world：
ngx.say(“hello world”);
lua-resty-limit-traffic模块
lua-resty-limit-traffic提供了管制最大mammalian连接数，天数询问处请求数，和光滑管制允诺数三种方式，分别对应：resty.limit.conn，resty.limit.count，resty.limit.req；相关文档能间接在pod/lua-resty-limit-traffic中找到，里面有完整的实例；
以下会用到三个共享字典，事先在http下配置：
http {
lua_shared_dict my_limit_conn_store 100m;
lua_shared_dict my_limit_count_store 100m;
lua_shared_dict my_limit_req_store 100m;
}
管制最大mammalian连接数提供的resty.limit.conn管制最大连接数，具体脚本如下：
local limit_conn = require “resty.limit.conn”
–B<syntax:> C<obj, err = class.new(shdict_name, conn, burst, default_conn_delay)>
local lim, err = limit_conn.new(“my_limit_conn_store”, 1, 0, 0.5)
if not lim then
ngx.log(ngx.ERR,
“failed to instantiate a resty.limit.conn object: “, err)
return ngx.exit(500)
end
local key = ngx.var.binary_remote_addr
local delay, err = lim:incoming(key, true)
if not delay then
if err == “rejected” then
return ngx.exit(502)
end
ngx.log(ngx.ERR, “failed to limit req: “, err)
return ngx.exit(500)
end
if lim:is_committed() then
local ctx = ngx.ctx
ctx.limit_conn = lim
ctx.limit_conn_key = key
ctx.limit_conn_delay = delay
end
local conn = err
if delay >= 0.001 then
ngx.sleep(delay)
end
new()参数分别是：字典名称，容许的最大mammalian允诺数，容许的突发性连接数，连接延迟；
incoming()中commit是两个布尔值，当为true时表示历史记录当前允诺的数量，否则就间接运行；
返回值：如果允诺不少于方法中指定的conn值，则此方法返回0作为延迟和当前天数的mammalian允诺（或连接）数；管制天数询问处允诺数提供的resty.limit.count能管制很大允诺数在两个天数询问处内，具体脚本如下：
local limit_count = require “resty.limit.count”
–B<syntax:> C<obj, err = class.new(shdict_name, count, time_window)>
–速度管制在20/10s
local lim, err = limit_count.new(“my_limit_count_store”, 20, 10)
if not lim then
ngx.log(ngx.ERR, “failed to instantiate a resty.limit.count object: “, err)
return ngx.exit(500)
end
local local key = ngx.var.binary_remote_addr
–B<syntax:> C<delay, err = obj:incoming(key, commit)>
local delay, err = lim:incoming(key, true)
if not delay then
if err == “rejected” then
return ngx.exit(503)
end
ngx.log(ngx.ERR, “failed to limit count: “, err)
return ngx.exit(500)
end
new()中指定的三个参数分别是：字典名称，指定的允诺共振频率，允诺个数复位前的询问处天数，以秒为单位；
incoming()中commit是两个布尔值，当为true时表示历史记录当前允诺的数量，否则就间接运行；
返回值：如果允诺数在管制范围内，则返回当前允诺被处置的延迟和将被处置的允诺的剩余数；光滑管制允诺数提供的resty.limit.req能已更加光滑的方式管制允诺，具体脚本如下：
local limit_req = require “resty.limit.req”
–B<syntax:> C<obj, err = class.new(shdict_name, rate, burst)>
–管制在200个允诺/秒以下，给与100个允诺/秒的突发性允诺；也就说每秒允诺最大能200-300之间，超出300报错
local lim, err = limit_req.new(“my_limit_req_store”, 200, 100)
if not lim then
ngx.log(ngx.ERR,
“failed to instantiate a resty.limit.req object: “, err)
return ngx.exit(500)
end
local key = ngx.var.binary_remote_addr
local delay, err = lim:incoming(key, true)
if not delay then
if err == “rejected” then
return ngx.exit(503)
end
ngx.log(ngx.ERR, “failed to limit req: “, err)
return ngx.exit(500)
end
if delay >= 0.001 then
local excess = err
ngx.sleep(delay)
end
new()三个参数分别是：字典名称，允诺速度（每秒数）共振频率，每秒容许延迟的过多允诺数；
incoming()中commit是两个布尔值，当为true时表示历史记录当前允诺的数量，否则就间接运行，能理解为两个开关；
返回值：如果允诺数在管制范围内，则此方法返回0作为当前天数的延迟和每秒过多允诺的（零）个数；
更多能间接查看官方文档：pod/lua-resty-limit-traffic目录下
总结
本文首先介绍了常用的开闭演算法，接着介绍在销售业务层民主化内和分布式系统应用分别是怎样展开开闭的，最后网络连接层通过OpenResty的lua-resty-limit-traffic模块展开开闭。
