整体思路说明：
对于并发限制请求，会统计当前的并发数，并发数统计原理：1次请求进入到限流模块incr 1；等请求结束退出时decr 1，当前正在处理的请求数就是并发数
对于QPS限制请求，统计QPS不能按照秒统计（第1s系统就可能就被打挂了），所以QPS得按照毫秒级别去统计，统计的级别越小，性能损耗越大，所以定在10ms-100ms的级别去统计，基本逻辑如下将1s中切成10份，每一份100ms，一个请求进来肯定会落在某一份上，这一份的计数值++，计算当前的QPS，只需要将当前时间所在份的计数和前面9份的技数相加；内存里面需要维护当前秒和前面2秒的数据，数据结构以环形数组为基础EndFragment
简单实例:
初始化上下文(第一次进入的时候才有效，后续都已经有了返回)
ContextUtil.enter("xxxxxx", this.getRequestPlatForm());
初始化
Entry entry = EntryUtil.entry("xxxx);
获取对应的value，然后根据调用链一次执行，修改计数。
@Override
public Entry entry(ResourceWrapper resourceWrapper) throws BlockException {
Context context = ContextUtil.getContext();
if(ContextUtil.isNullContext(context)) {
//空 不需要判断
return new CtEntry(null , context);
}
if(context == null) {
//创建默认
context = MyContextUtil.myEnter(Constants.CONTEXT_DEFAULT_NAME, "", this);
}
if(!Constants.ON) {
return new CtEntry(null, context); // 开关不生效
}
IProcessorValve valves = getProcessorValves(resourceWrapper);
if(valves == null) {
return new CtEntry(null, context);
}
Entry entry = new CtEntry(valves, context);
try{
//规则判断，计数修改
valves.entry(resourceWrapper, context, null);
}catch(BlockException e){
//阻塞的总计数修改
Tracer.trace(BlockException.BLOCK);
entry.exit();
throw e;
}catch(Throwable e) {
//理论上不会有这个异常
log.error("unknow exception", e);
}
return entry;
}
最后一步执行统计流程：
@Override
public void entry(ResourceWrapper resourceWrapper, Context context, DefaultDom dom) throws Throwable {
// 设置originDom
if (!context.getOrigin().equals("")) {
Dom originDom = dom.getResourceDom().getOriginDom(context.getOrigin());
context.getCurEntry().setOriginDom(originDom);
}
try {
// 先执行其他的Valve
super.fireEntry(resourceWrapper, context, dom);
dom.increasePassRequest();
dom.increaseThreadNum();
dom.add();//增加对应的统计数据
// 一条链路，或者说一个context对应一个originDom，有可能originDom不存在（比如：origin为""）
if (context.getCurEntry().getOriginDom() != null) {
context.getCurEntry().getOriginDom().increasePassRequest();
context.getCurEntry().getOriginDom().increaseThreadNum();
context.getCurEntry().getOriginDom().add();
}
} catch (Throwable ex) {
if (ex instanceof BlockException) {
dom.increaseBlockedRequest();
if (context.getCurEntry().getOriginDom() != null) {
context.getCurEntry().getOriginDom().increaseBlockedRequest();
}
}
context.getCurEntry().setError(ex);
throw ex;
}
}
数据增加，最终算法：
public void add(int value) {
if (value > Constants.MAX_TIME_VALUE){
value = Constants.MAX_TIME_VALUE;
}
//如 xxx1111毫秒
long currentTime = TickUtil.currentTimeMillis();
//通过进度计算，对应到具体的精度值。如精度为100ms，xxx11为进度值
long timeGranularity = currentTime / precision;
//根据具体的时间节点值，映射到具体的时间环分片。30个时间分片(保留3s的数据)，对应到的分片为11分片。
int index = (int) (timeGranularity % time.length);
do{
int recordPassCnt = passCnt[index].get();
int recordBlockCnt = blockCnt[index].get();
int recordRt = rt[index].get();
long recordTime = time[index].get();
if ( timeGranularity == recordTime ){
//对应分片的统计数据增加
if (value < 0){
if (blockCnt[index].compareAndSet(recordBlockCnt,recordBlockCnt + 1)){
break;
}
}else{
boolean result = rt[index].compareAndSet(recordRt, recordRt + value);
result = result && passCnt[index].compareAndSet(recordPassCnt, recordPassCnt + 1);
if (result || time[index].get() != timeGranularity){
break;
}
}
} else if(timeGranularity > recordTime){//如果超过时间环一圈，如，41对应的分片也为11，需要先清空分片数据，然后再重新统计。
synchronized (time[index]) {
if (timeGranularity > time[index].get()) {
time[index].set(-1);
passCnt[index].set(-1);
blockCnt[index].set(-1);
rt[index].set(-1);
time[index].set(timeGranularity);
if (value < 0) {
passCnt[index].addAndGet(1);
blockCnt[index].addAndGet(2);
rt[index].addAndGet(1);
} else {
passCnt[index].addAndGet(2);
blockCnt[index].addAndGet(1);
rt[index].addAndGet(1 + value);
}
break;
}
}
}else {
break;
}
Thread.yield();
}while(true);
}
数据统计算法：
@Override
public int[] getAvgQpsAndRt() {
long currentTime = TickUtil.currentTimeMillis();
long endTimeGranularity = currentTime / precision;
int index = (int) (endTimeGranularity % time.length);
long startTimeGranularity = endTimeGranularity - sampleCnt;
long totalPassCnt = 0;
long totalBlockCnt = 0;
long totalRt = 0;
//向前统计N个时间片的数据，比如可以统计1s的数据，精度为100ms，则samplCnt值为10，共取10个分片数据，计算qps和rt
for (int i = 0; i < sampleCnt; i++){
long recordTime = time[index].get();
if (recordTime <= endTimeGranularity && recordTime > startTimeGranularity){
int recordPass = passCnt[index].get();
int recordBlock = blockCnt[index].get();
int recordRt = rt[index].get();
if (recordTime == time[index].get()) {
totalPassCnt += recordPass;
totalBlockCnt += recordBlock;
totalRt += recordRt;
}else{
startTimeGranularity = recordTime - 1;
break;
}
} else if (recordTime > endTimeGranularity){
startTimeGranularity = recordTime - 1;
break;
}
index = (index -1 + time.length) % time.length;
}
long duration = precision * sampleCnt;
int[] avgResult = new int[]{0,0,0}; //passCnt, blockCnt, rt
if (duration != 0){
avgResult[0] = (int) (totalPassCnt * 1000 / duration);
avgResult[1] = (int) (totalBlockCnt * 1000 / duration);
avgResult[2] = (int) Math.ceil((double)totalRt / (totalPassCnt == 0 ? 1 : totalPassCnt));
}
return avgResult;
数据限流算法：
执行最终的计数算法之前，首先要执行规则检查：
@Override
public void entry(ResourceWrapper resourceWrapper, Context context, DefaultDom dom) throws Throwable {
// 设置originDom
if (!context.getOrigin().equals("")) {
Dom originDom = dom.getResourceDom().getOriginDom(context.getOrigin());
context.getCurEntry().setOriginDom(originDom);
}
try {
// 先执行其他的Valve,限制性：qps、并发限流等规则检查(详见下：)
super.fireEntry(resourceWrapper, context, dom);
dom.increasePassRequest();
dom.increaseThreadNum();
dom.add();
// 一条链路，或者说一个context对应一个originDom，有可能originDom不存在（比如：origin为""）
if (context.getCurEntry().getOriginDom() != null) {
context.getCurEntry().getOriginDom().increasePassRequest();
context.getCurEntry().getOriginDom().increaseThreadNum();
context.getCurEntry().getOriginDom().add();
}
} catch (Throwable ex) {
if (ex instanceof BlockException) {
dom.increaseBlockedRequest();
if (context.getCurEntry().getOriginDom() != null) {
context.getCurEntry().getOriginDom().increaseBlockedRequest();
}
}
context.getCurEntry().setError(ex);
throw ex;
}
}
//该方法为对应的检查规则的方法
@Override
public boolean checkRule(Context context, DefaultDom dom) {
// 获取此规则的受限应用(可能是来源，本身，或者去向)
String limitApp = this.getLimitApp();
// 如果此规则无限制应用，立即通过
if (limitApp == null) {
return true;
}
// 统计值
long count = -1L;
// 来源限流
String origin = context.getOrigin();
// 按照流向计算
switch (type) {
case FlowConstant.TYPE_RESOURCE:
count = getResourceCount(dom);
break;// 此资源本身的总限流
case FlowConstant.TYPE_ORIGIN:
count = getOriginCount(limitApp, origin, context, dom);
break;// 此资源来源的限流
case FlowConstant.TYPE_DESTINATION:
count = getDestinationCount(limitApp, context, dom);// 此资源去向的限流
}
// 如果当前的值已经=或>阀值，则return false
if (count >= threshold) {
return false;
}
return true;
}
//检查是否超过了qps限流值
private long getOriginCount(final String limitApp, final String origin, final Context context, final DefaultDom dom) {
long count = -1L;
if (limitApp.equals(origin)) {// limitApp与来源相同的限流
count = strategy == FlowConstant.STRATEGY_QPS ? context.getOriginPassedReqQps() : context.getOriginCurThreadNum();
} else if (limitApp.equals(FlowConstant.APP_DEFAULT)) {// 所有的来源,即资源的总限流（也可以设置type字段为resource的类型获得相同结果）
count = strategy == FlowConstant.STRATEGY_QPS ? dom.getResourceDom().passReqQps() : dom.getResourceDom().curThreadNum();
} else if (limitApp.equals(FlowConstant.APP_OTHER) && FlowManager.isOtherOrigin(getIdentity(), origin)) {// 其他的来源限流
count = strategy == FlowConstant.STRATEGY_QPS ? context.getOriginPassedReqQps() : context.getOriginCurThreadNum();
}
return count;
}