我们知道，将服务按照业务拆分或者将服务集群化都好，本质上是为了降低第三方访问服务器时执行的压力，但是，就算听过集群化或者业务拆分，当访问量激增的时候，服务响应时间过长或者异常出错的话，如何做到维护系统的稳定呢？目前了解的最终手段是：限流降级熔断。
Sentinel：
1.限流手段：线程并发量以及QPS；
2.降级熔断：按照平均响应时间，异常比例或者异常个数来判断在指定时间内将新的请求按照指定的降级逻辑来处理；
先说到限流，既然需要限流，那么做到统计流量；同时，如果需要知道限流的执行链，那么需要记录：在sentinel主要是通过节点node来完成以上操作的，并且通过责任链模式来对限流（降级熔断，黑白名单等）方案进行判断的，如果不满足，则一层一层往上异常即可。入口：
Entry entry1 = SphU.entry(KEY);
最终进入这个关键：
参数：ResourceWrapper 是对应于每一个需要执行的对象，
接着：
在这里创建一个入口节点，并且对应于对应于线程上下文名称的，可以看出来的是，这里是以名称为key的，也就是说如果定义的context名称一样的话，那么就会给新的资源替换；注意到这个： Constants.ROOT ， 初始化时：
也就是说到目前为止，每一次资源的访问都会以全局唯一的入口，自身线程入口的节点链表：
接着看判断是否全局禁止检查，如果不是，则执行：
ProcessorSlot chain = lookProcessChain(resourceWrapper);
此处代码相当关键的生成了执行链，用来对生成两大统计节点：DefaultNode 以及 ClusterNode，以及执行是否限流降级熔断，黑名单的拦截，日志的记录等；
通过这
private static volatile Map<ResourceWrapper, ProcessorSlotChain> chainMap
= new HashMap<ResourceWrapper, ProcessorSlotChain>(); 可以看出来这个执行链是一一对应资源对象的，看： chain = SlotChainProvider.newSlotChain();
在这里就需要看到：SpiLoader 这个 SERVICE_LOADER_MAP 在什么时候初始赋值的了：
查询发现，在：
在一开始进入方法的时候就会进去经过静态方法到这里，在这里利用了jdk的spi技术，这也是sentinel提供的可扩展的地方；
其中：
CommandCenterInitFunc 是负责开始netty服务，用于跟控制台通讯调用用的，主要的需要注意的逻辑就是封装map，按照请求的类型找出对应的处理方法类对象；
HeartbeatSenderInitFunc 是负责与控制台的心跳，主要是开始定时任务来处理发送心跳的逻辑；
MetricCallbackInit 是开始回调，是响应控制台的执行访问的服务执行链等实时数据的回调方法；
回到：loadFirstInstanceOrDefault
由于需要取出的是：SlotChainBuilder 原来并没有存在，所以又利用spi来加载了：DefaultSlotChainBuilder，最后执行了：
可以看出来，兜了一大圈终于看到了这个责任链：
NodeSelectorSlot ： 主要是创建：DefaultNode ，形成当前线程的执行节点链；
ClusterBuilderSlot ：主要生成了：ClusterNode，一个资源对象对应一个node，用于全局计算；
LogSlot : 日志
StatisticSlot ： 统计信息
AuthoritySlot：权限
SystemSlot：系统
FlowSlot：限流
DegradeSlot：降级熔断”
最后回到：
Entry e = new CtEntry(resourceWrapper, chain, context);
这里就构造了Entry对象。可以看出来，任何对象，调用一次就生成一个对象
可以看出来：这个 CtEntry 包含了对应的资源，封装了执行链，对应线程执行上下文，并且调用：setUpEntryFor 方法来
生成: Entry 的执行链，这样到目前为止，就已经生成了：
- 统计信息，判断信息的执行链
- 节点的执行链
- CtEntry的执行链
这样控制台就可以根据这些信息来显示对应的可视化调用趋势数据了：具体到每一个节点资源的信息看图：
第一次执行资源的判断
第二次执行资源的话：
接着就会在之前生成的用来记录执行资源路径的node以及过滤用的执行链上操作了：
先看异常处理，可以看出如果在当中出现异常的话，捕获向上抛，限流的异常处理就可以由业务员开发者处理了；
每一个slot 类都继承了 AbstractLinkedProcessorSlot ，通过调用它的：transformEntry 方法来调用下一个slot
先看这个：NodeSelectorSlot：
可以看出来这个DefaultNode首先以资源为对象，然后在每一个线程Context上创建对象，线程之间的DefaultNode相互不影响；
再看：ClusterBuilderSlot
可以看出来这个创建了仅仅以资源为维度的：ClusterNode
@Override
public void entry(Context context, ResourceWrapper resourceWrapper, DefaultNode node, int count,
boolean prioritized, Object... args) throws Throwable {
try {
// Do some checking.
fireEntry(context, resourceWrapper, node, count, prioritized, args);
// Request passed, add thread count and pass count.
node.increaseThreadNum();
node.addPassRequest(count);
if (context.getCurEntry().getOriginNode() != null) {
// Add count for origin node.
context.getCurEntry().getOriginNode().increaseThreadNum();
context.getCurEntry().getOriginNode().addPassRequest(count);
}
if (resourceWrapper.getEntryType() == EntryType.IN) {
// Add count for global inbound entry node for global statistics.
Constants.ENTRY_NODE.increaseThreadNum();
Constants.ENTRY_NODE.addPassRequest(count);
}
// Handle pass event with registered entry callback handlers.
for (ProcessorSlotEntryCallback<DefaultNode> handler : StatisticSlotCallbackRegistry.getEntryCallbacks()) {
handler.onPass(context, resourceWrapper, node, count, args);
}
} catch (PriorityWaitException ex) {
node.increaseThreadNum();
if (context.getCurEntry().getOriginNode() != null) {
// Add count for origin node.
context.getCurEntry().getOriginNode().increaseThreadNum();
}
if (resourceWrapper.getEntryType() == EntryType.IN) {
// Add count for global inbound entry node for global statistics.
Constants.ENTRY_NODE.increaseThreadNum();
}
// Handle pass event with registered entry callback handlers.
for (ProcessorSlotEntryCallback<DefaultNode> handler : StatisticSlotCallbackRegistry.getEntryCallbacks()) {
handler.onPass(context, resourceWrapper, node, count, args);
}
} catch (BlockException e) {
// Blocked, set block exception to current entry.
context.getCurEntry().setError(e);
// Add block count.
node.increaseBlockQps(count);
if (context.getCurEntry().getOriginNode() != null) {
context.getCurEntry().getOriginNode().increaseBlockQps(count);
}
if (resourceWrapper.getEntryType() == EntryType.IN) {
// Add count for global inbound entry node for global statistics.
Constants.ENTRY_NODE.increaseBlockQps(count);
}
// Handle block event with registered entry callback handlers.
for (ProcessorSlotEntryCallback<DefaultNode> handler : StatisticSlotCallbackRegistry.getEntryCallbacks()) {
handler.onBlocked(e, context, resourceWrapper, node, count, args);
}
throw e;
} catch (Throwable e) {
// Unexpected error, set error to current entry.
context.getCurEntry().setError(e);
// This should not happen.
node.increaseExceptionQps(count);
if (context.getCurEntry().getOriginNode() != null) {
context.getCurEntry().getOriginNode().increaseExceptionQps(count);
}
if (resourceWrapper.getEntryType() == EntryType.IN) {
Constants.ENTRY_NODE.increaseExceptionQps(count);
}
throw e;
}
这个类主要功能是后面就是执行真正的过滤作用的了：
AuthoritySlot–》SystemSlot–》FlowSlot–》DegradeSlot；
看下面的：
// Request passed, add thread count and pass count.
node.increaseThreadNum(); node.addPassRequest(count);
在这里开始了统计数据：首先对每个线程上的对应的资源: DefaultNode
统计当前节点的并发数是直接通过jdk8的实现原子性操作的 LongAddr 来实现累计；
我们重点来学习下下面有关滑动窗口计算的逻辑：
先来大概说一下滑动窗口：
比如现在要统计一秒内的并发量，我们可以用个数据记录：
用图表示:
- 获取对应的数组位置idx，没有的话则创建一个对象，有的话继续
- 判断当前的请求时间，如原来的窗口对象的起始时间作比较，如果大于的话，则覆盖原来旧的，如果相等话则在原来的数据上加1即可；
看代码：
---------StatisticNode
@Override
public void addPassRequest(int count) {
rollingCounterInSecond.addPass(count);
rollingCounterInMinute.addPass(count);
}
----------ArrayMetric：
@Override
public void addPass(int count) {
WindowWrap<MetricBucket> wrap = data.currentWindow();
wrap.value().addPass(count);
}
public WindowWrap<T> currentWindow(long timeMillis) {
if (timeMillis < 0) {
return null;
}
int idx = calculateTimeIdx(timeMillis);
long windowStart = calculateWindowStart(timeMillis);
while (true) {
WindowWrap<T> old = array.get(idx);
if (old == null) {
WindowWrap<T> window = new WindowWrap<T>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
if (array.compareAndSet(idx, null, window)) {
return window;
} else {
Thread.yield();
}
} else if (windowStart == old.windowStart()) {
return old;
} else if (windowStart > old.windowStart()) {
if (updateLock.tryLock()) {
try {
return resetWindowTo(old, windowStart);
} finally {
updateLock.unlock();
}
} else {
Thread.yield();
}
} else if (windowStart < old.windowStart()) {
return new WindowWrap<T>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
}
}
}
很明显，sentinel 采用的对象 ArrayMetric 来封装所有的窗口，没有个窗口对应一个WindowWrap ，而在每个 WindowWrap 里面记录数据的是 MetricBucket；sentinel 首先根据当前请求时间戳对应哪个数据位置，再来计算对应的位置的起始时间，计算逻辑很简单：
long idx = (System.currentTimeMillis() / windowLengthInMs) % array.length();
long timeMillis - System.currentTimeMillis()% windowLengthInMs;
windowLengthInMs 对应每一个小的时间长度，array.length()对应总的时间窗口数组的长度；
1.存在旧的时间窗口以及对应的窗口起始时间的等于原来的话，则在返回旧的对象
2.不存在的话则直接生成；
3…存在旧的时间窗口以及对应的窗口起始时间的大于原来的话，则：
调用：resetWindowTo 方法将原来的窗口覆盖，并返回 addPass，里面也是封装了 LongAddr的数组，在通过节点上的基础上原子性+1；这样就完成了利用滑动窗口的统计了；
最后就调用到exit 方法，将统计的并发线程数减1等操作；
另外，sentinel 在使用上还可以结合不同的限流降级策略：
- 直接拒接，抛出异常
- 预热
- 匀速排队：相当于漏桶的解方式一样，
降级熔断：
sentinel 在处理熔断这块提供了三种策略：
4. 根据平均响应时间：比如在配置的规则 1s 内响应的超过配置的timeout 的话，则在配置的延迟时间段内不会再接受新的请求，直接阻塞异常
5. 根据异常比例：比如在配置的规则 1s 内响应的异常配置的次数并且请求数目大于设定值的话，则在配置的延迟时间段内不会再接受新的请求，直接阻塞异常
6. 根据异常请求数： 比如在配置的规则 1s 内响应的异常配置的次数的话，则在配置的延迟时间段内不会再接受新的请求，直接阻塞异常；求出新的请求时间与前一个的请求时间差，比较如果大于配置的时间差的话，则直接执行；如果小于的话，则需要进行排队计算出前面的排队的时间总和，并与配置的超时时间比较，如果大于的话则异常，如果不是的话，则排队等待执行；
728
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
