服务熔断降级

之前给大家讲了很多服务之前的关系，今天主要给大家介绍，当服务出现问题时，我们该如何解决。

首先我们先进行一些场景分析：

• 场景一

服务提供端提供了A、B、C、D 4个服务，服务调用方调用服务时，D服务出现了问题，导致调用服务D的请求都出现了超时或者错误，从而进一步影响了整个请求队列的性能。

• 场景二

我们根据client1和client2 的请求压力确定了我们serverA的负载情况，但是当client2的请求从1500 增加到15000 时，会远远大于ServerA 的性能瓶颈，这个时候也会导致Client1的请求出现超时或者失败的情况。

总结一下，会有哪些情形导致我们服务出现不可以，需要我们做容错呢？

• 单个节点故障，可能被无限向上放大
• 多租户相互影响
• 瞬时流量激增，系统扛不住

针对上面总结的场景，我们有哪些解决方案呢？

• 资源隔离
• 熔断
• 降级

1、资源隔离

资源隔离主要是对线程资源进行隔离。这里有两种方法进行隔离：使用线程池和信号量

（1）线程池隔离

使用线程池进行资源隔离，我们有两种途径，一种是在服务端，根据不同的请求类型划分不同的队列进行处理，比如我们可以根据业务的优先级，创建高中低、默认等优先级队列来处理业务请求。

还有一种方式是通过在服务调用端进行队列划分，比如我们有多个服务进行调研，每个调用内部都有一个队列，通过连接管理的方式进行服务调用

（2）信号量

还有一种方式是通过信号量的方式来实现。我们可以通过给每个服务提供方设置可用的信号量来实现资源隔离。

（3）对比

信号量与线程池对比

下面我们来具体分析下服务熔断和降级的设计应用。

2、服务熔断

什么叫服务熔断？

服务熔断就是临时关闭对某些功能的调用，个别的业务不可用，但是系统整体可用

有哪些服务熔断的具体例子呢？

比如一些大的电商平台在双11那天关闭退款入口，关闭换头像功能等等，这些功能的关闭对于用户来说是可感知的。

在做服务熔断设计中，我们需要关注哪些点呢？

• 可熔断服务

我们需要判断在我们的整体架构中，哪些服务是可用进行熔断的，哪些是核心业务，不能出现不可用的情况。

• 熔断触发：触发熔断的方式有哪些
  • 主动熔断：系统管理员根据将要出现的场景，提前关闭某些服务
  • 被动熔断：系统根据服务的状态触发熔断
• 恢复时机

3、服务降级

什么叫服务降级？

服务降级就是有损的提供服务，保证服务柔性可用。

业务中有哪些服务降级的场景呢？

比如我们在请求高峰期的时候，对于用户的个人推荐，我们返回兜底数据；计数服务返回假数据等。这些服务对于用户来说他是不易感知的。

我们在进行服务降级设计时，需要考虑到哪些方面呢？

• 可降级服务

首先我们要确认在我们的整体架构中，哪些服务是可以采用降级的方案的，哪些场景不适合降级的方法

• 降级方法

我们一般的降级方法有哪些，比如常见的默认返回等等

• 降级触发

降级触发的条件是什么，现在有2种常见的情况：主动和被动

主动：管理员发现某个服务出现异常，通过手动的方式触发某个服务的熔断，这是我们需要有一个降级的方法

被动：当某个服务调用超时或者异常，采用降级方案

• 恢复时机

触发降级服务后，什么时候恢复到原来的服务？

4、熔断降级

基于上面的描述，我们可以发现，降级熔断都是系统可用性可靠性的保障手段，为了保障服务的柔性可用。

• 目标一致：都是从可用性和可靠性出现，为了防止系统崩溃
• 用户体验：用户感受到某些功能的暂不可用

很多时候，降级和熔断是配置使用的

5、断路器设计

断路器

服务熔断的开关，当对下游服务调用异常量达到设定阈值后，打开断路器，触发熔断

（1）断路器的状态流转

• 断路器的状态分为3个状态，closed(关闭)，open(打开)，half open(半打开)，服务正常使用时，断路器的状态为关闭的；
• 当服务调用在指定时间内达到一定的阈值，就会打开断路器，服务熔断；
• 当达到关闭时间后，会将断路器的状态更新为halfopen，将少部分流量打到之前熔断的服务；
• 如何服务调用正常，则将断路器状态更新为closed，否则更新为open

（2）阈值与统计数据

• 阈值的数据类型
  • 我们一般采用百分比的方式，比如失败率达到多少多少我们出发熔断
• 颗粒度
  • 我们一般是针对某个节点中的某个实例的某个方法而言，当某个方法的调用失败率达到一定的程度，我们就触发对该方法调用的熔断
• 统计

数据结构：如上图，我们需要在规定的时间范围内进行统计，只需要统计最近10个slot范围内的数据，根据场景，我们的数据结构可以是链表，或者循环数组，滑动窗口伪代码实现如下：

// 整个循环数组的结构 public class BucketCircularArray { 
    private volatile int size =10; private static int maxSize = 60; private volatile int dataLength; private Bucket[] data; private int head; private int tail; } // 每个slot的数据结构 public class Bucket { 
    private final long windowStart; private AtomicInteger successNum; private AtomicInteger failNum; private AtomicInteger timeoutNum; } 

public void addBucket(Bucket bucket) { 
    data[tail] = bucket; incrementTail(); } private void incrementTail() { 
    if (dataLength == size) { 
    // the size change head = (head + 1) % size; tail = (tail + 1) % size; } else { 
    tail = (tail + 1) % size; } if (dataLength < size) { 
    dateLength++; } } public Bucket tail() { 
    if (dateLength == 0) { 
    return null; } int index = (head + dataLength -1) % dataLength; return data[index]; } public Bucket[] toArray() { 
    ArrayList<Bucket> list = new ArrayList<Bucket>(); for (int i = 0; i < dataLength; i++) { 
    int index = (head + i) % dataLength; Bucket tmp = data[index]; if (tmp != null) { 
    list.add(tmp); } } return list.toArray(new Bucket[list.size()]); } 

// 断路器CircuitBreaker // open -> half_open public boolean attemptExecution() { 
    CircuitBreakConfigMeta configData = this.srvMgrClient.getCircuitBreakConfig(serviceName, method); ...... ...... } else { 
    if (isAfterSleepWindow(configData)) { 
    if (status.compareAndSet(Status.OPEN, Status.HALF_OPEN)) { 
    halfOpenPassNum.set(0); return true; } else { 
    if (halfOpenPassNum.incrementAndGet() > maxHalfOpenPassNum) return false; else return true; } } else { 
    return false; } } } private boolean isAfterSleepWindow(CircuitBreakConfigMeta configData) { 
    final long circuitOpenTime = circuitOpened.get(); final long currentTime = System.currentTimeMillis(); final long sleepWindowTime = configData.getSleepwindowInMilliseconds(); return currentTime > circuitOpenTime + sleepWindowTime; } // hald_open -> closed public void markSuccess() { 
    boolean flag = false; if (status.compareAndSet(Status.HALF_OPEN, Status.CLOSED)) { 
    circuitOpened.set(-1L); flag = true; } return flag; } // closed -> open public boolean tryMarkOpen(int errorPercentage, Long requestNum) { 
    circuitBreakConfigMeta configData = this.srvMgrClient.getCircuitBreakConfig(serviceName, method); if (configData != null && !configData.isForceClosed() && requestNum >= configData.getRequestVolumThreshold() && errorPecentage >= configData.getErrorThresholdPercentage()) { 
    if (status.compareAndSet(Status.CLOSED, Status.OPEN)) { 
    circuitOpened.set(System.currentTimeMillis()); return true; } } return false; } // half_open -> open public void markNonSuccess() { 
    if (status.compareAndSet(Status.HALF_OPEN, Status.OPEN)) { 
    logger.debug("circuitBreakerName {} reset to open", circuitBreakerName); circuitOpened.set(System.currentTimeMillis()); } } 

// 控制器对象：MetricTimeWindow public MetricTimeWindow(String serviceName, String method, ScfClientService srvMgrClient, int windowLength, EventBus eventBus) { 
    this.metricName = serviceName + "@" + method; this.serviceName = serviceName; this.method = method; this.bucketArray = new BucketCircularArray(windowLength); this.circuitBreaker = new CircuitBreaker(serviceName, method, srvMgrClient); } // 处理事件，成功、失败、超时 public void addEvent(MetricEventType event) { 
    Bucket bucket = getCurrentBucket(); switch(event) { 
    case success: bucket.getSuccessNum().incrementAndGet(); boolean makeClosed = circuitBreaker.markSuccess(); break; case fail: bucket.getFailNum().incrementAndGet(); this.circuitBreaker.markNonSuccess(); break; case timeout: bucket.getTimeoutNum().incrementAndGet(); this.circuitBreaker.markNonSuccess(); break; } } public boolean markSuccess() { 
    boolean flag = false; if (status.compareAndSet(Status.HALF_OPEN, Status.CLOSED)) { 
    circuitOpened.set(-1L); flag = true; } return flag; } public void markNonSuccess() { 
    if (status.compareAndSet(Status.HALF_OPEN, Status.OPEN)) { 
    logger.debug("circuitBreakerName {} reset to open", circuitBreakerName); circuitOpened.set(System.currentTimeMillis()); } } // 获取当前的bucket public Bucket getCurrentBucket() { 
    long currentTime = System.currentTimeMillis(); lock.readLock().lock(); Bucket bucket = null; try { 
    bucket = bucketArray.tail(); if (bucket != null && currentTime <= (bucket.getWindowStart() + bucketTimeSpan)) return bucket; } finally { 
    lock.readLock().unlock(); } boolean createNewBucket = false; lock.writeLock().lock(); try { 
    Bucket check = bucketArray.tail(); if (check != null && currentTime <= (check.getWindowStart() + bucketTimeSpan)) { 
    bucket = check; } else { 
    bucket = new Bucket(currentTime); bucketArray.addBucket(bucket); createNewBucket = true; } } finally { 
    lock.writeLock().unlock(); } if (createNewBucket) { 
    dealCreateBucketEvent(); } return bucket; } private void dealCreateBucketEvent() { 
    Bucket[] data = null; lock.readLock().lock(); data = bucketArray.toArray(); if (data == null || data.length == 0) { 
    return; } long successNum = 0L; long failNum = 0L; for (int i = 0; i < data.length; i++) { 
    Bucket tmp = data[i]; successNum += tmp.getSuccessNum().get; failNum += tmp.getFailNum().get; failNum += tmp.getTimeoutNum().get; } Long reqNum = successNum + failNum; int errorPercentage = (int) ((double) failNum / (successNum + failNum) * 100); circuitBreaker.tryMarkOpen(errorPercentage, reqNum); } 

6、Hystrix应用

Hystrix 语义为“豪猪”，是由Netflix开源的一个服务隔离组件，通过服务隔离来避免由于依赖延迟、异常，引起资源耗尽导致系统不可用的解决方案。

（1）解决问题

• 阻止某个有问题调用耗尽系统的所有线程
• 阻止错误在分布式系统之间的传播
• 快速识别代替请求排队
• 错误回退、优雅的服务降级

（2）问题出现原因

• 服务提供者不可用：某依赖不可用，请求无法正常返回
• 重试加大流量：代码重试逻辑或客户端重试，导致流量加大
• 服务调用者不可用：线程资源耗尽，导致服务调用者不可用

解决方案：对依赖做隔离

（3）依赖隔离

• 包装依赖调用逻辑，每个命令在单独线程中执行
• 可配置依赖调用超时时间，当调用超时时，执行fallback逻辑
• 线程池已满调用将被立即拒绝，快速失败判断
• 依赖调用请求失败（异常、拒绝、超时、断路）时执行fallback逻辑
• 提供熔断器组件，可以自动运行或手动调用

（4）主要特性

• 资源隔离：限制调用服务使用的资源，当某一下游服务出现问题时，不会影响整个调用链
• 熔断机制：当失败率达到阈值自动触发熔断，熔断器触发不在进行调用
• 降级机制：超时、资源或触发熔断后，调用预设的降级接口返回托底数据

（5）Hystrix执行逻辑