熔断原理与实现Golang版

在微服务中服务间依赖很是常见，好比评论服务依赖审核服务而审核服务又依赖反垃圾服务，当评论服务调用审核服务时，审核服务又调用反垃圾服务，而这时反垃圾服务超时了，因为审核服务依赖反垃圾服务，反垃圾服务超时致使审核服务逻辑一直等待，而这个时候评论服务又在一直调用审核服务，审核服务就有可能由于堆积了大量请求而致使服务宕机

因而可知，在整个调用链中，中间的某一个环节出现异常就会引发上游调用服务出现一些列的问题，甚至致使整个调用链的服务都宕机，这是很是可怕的。所以一个服务做为调用方调用另外一个服务时，为了防止被调用服务出现问题进而致使调用服务出现问题，因此调用服务须要进行自我保护，而保护的经常使用手段就是熔断

熔断器原理

熔断机制实际上是参考了咱们平常生活中的保险丝的保护机制，当电路超负荷运行时，保险丝会自动的断开，从而保证电路中的电器不受损害。而服务治理中的熔断机制，指的是在发起服务调用的时候，若是被调用方返回的错误率超过必定的阈值，那么后续的请求将不会真正发起请求，而是在调用方直接返回错误

在这种模式下，服务调用方为每个调用服务(调用路径)维护一个状态机，在这个状态机中有三个状态：

• 关闭(Closed)：在这种状态下，咱们须要一个计数器来记录调用失败的次数和总的请求次数，若是在某个时间窗口内，失败的失败率达到预设的阈值，则切换到断开状态，此时开启一个超时时间，当到达该时间则切换到半关闭状态，该超时时间是给了系统一次机会来修正致使调用失败的错误，以回到正常的工做状态。在关闭状态下，调用错误是基于时间的，在特定的时间间隔内会重置，这可以防止偶然错误致使熔断器进去断开状态
• 打开(Open)：在该状态下，发起请求时会当即返回错误，通常会启动一个超时计时器，当计时器超时后，状态切换到半打开状态，也能够设置一个定时器，按期的探测服务是否恢复
• 半打开(Half-Open)：在该状态下，容许应用程序必定数量的请求发往被调用服务，若是这些调用正常，那么能够认为被调用服务已经恢复正常，此时熔断器切换到关闭状态，同时须要重置计数。若是这部分仍有调用失败的状况，则认为被调用方仍然没有恢复，熔断器会切换到关闭状态，而后重置计数器，半打开状态可以有效防止正在恢复中的服务被忽然大量请求再次打垮

服务治理中引入熔断机制，使得系统更加稳定和有弹性，在系统从错误中恢复的时候提供稳定性，而且减小了错误对系统性能的影响，能够快速拒绝可能致使错误的服务调用，而不须要等待真正的错误返回

熔断器引入

上面介绍了熔断器的原理，在了解完原理后，你是否有思考咱们如何引入熔断器呢？一种方案是在业务逻辑中能够加入熔断器，但显然是不够优雅也不够通用的，所以咱们须要把熔断器集成在框架内，在zRPC框架内就内置了熔断器

咱们知道，熔断器主要是用来保护调用端，调用端在发起请求的时候须要先通过熔断器，而客户端拦截器正好兼具了这个这个功能，因此在zRPC框架内熔断器是实如今客户端拦截器内，拦截器的原理以下图：

对应的代码为：

func BreakerInterceptor(ctx context.Context, method string, req, reply interface{},
	cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
  // 基于请求方法进行熔断
	breakerName := path.Join(cc.Target(), method)
	return breaker.DoWithAcceptable(breakerName, func() error {
    // 真正发起调用
		return invoker(ctx, method, req, reply, cc, opts...)
    // codes.Acceptable判断哪一种错误须要加入熔断错误计数
	}, codes.Acceptable)
}

熔断器实现

zRPC中熔断器的实现参考了Google Sre过载保护算法，该算法的原理以下：

• 请求数量(requests)：调用方发起请求的数量总和
• 请求接受数量(accepts)：被调用方正常处理的请求数量

在正常状况下，这两个值是相等的，随着被调用方服务出现异常开始拒绝请求，请求接受数量(accepts)的值开始逐渐小于请求数量(requests)，这个时候调用方能够继续发送请求，直到requests = K * accepts，一旦超过这个限制，熔断器就回打开，新的请求会在本地以必定的几率被抛弃直接返回错误，几率的计算公式以下：

经过修改算法中的K(倍值)，能够调节熔断器的敏感度，当下降该倍值会使自适应熔断算法更敏感，当增长该倍值会使得自适应熔断算法下降敏感度，举例来讲，假设将调用方的请求上限从 requests = 2 * acceptst 调整为 requests = 1.1 * accepts 那么就意味着调用方每十个请求之中就有一个请求会触发熔断

代码路径为go-zero/core/breaker

type googleBreaker struct {
	k     float64  // 倍值 默认1.5
	stat  *collection.RollingWindow // 滑动时间窗口，用来对请求失败和成功计数
	proba *mathx.Proba // 动态几率
}

自适应熔断算法实现

func (b *googleBreaker) accept() error {
	accepts, total := b.history()  // 请求接受数量和请求总量
	weightedAccepts := b.k * float64(accepts)
  // 计算丢弃请求几率
	dropRatio := math.Max(0, (float64(total-protection)-weightedAccepts)/float64(total+1))
	if dropRatio <= 0 {
		return nil
	}
	// 动态判断是否触发熔断
	if b.proba.TrueOnProba(dropRatio) {
		return ErrServiceUnavailable
	}

	return nil
}

每次发起请求会调用doReq方法，在这个方法中首先经过accept效验是否触发熔断，acceptable用来判断哪些error会计入失败计数，定义以下：

func Acceptable(err error) bool {
	switch status.Code(err) {
	case codes.DeadlineExceeded, codes.Internal, codes.Unavailable, codes.DataLoss: // 异常请求错误
		return false
	default:
		return true
	}
}

若是请求正常则经过markSuccess把请求数量和请求接受数量都加一，若是请求不正常则只有请求数量会加一

func (b *googleBreaker) doReq(req func() error, fallback func(err error) error, acceptable Acceptable) error {
	// 判断是否触发熔断
  if err := b.accept(); err != nil {
		if fallback != nil {
			return fallback(err)
		} else {
			return err
		}
	}

	defer func() {
		if e := recover(); e != nil {
			b.markFailure()
			panic(e)
		}
	}()
	
  // 执行真正的调用
	err := req()
  // 正常请求计数
	if acceptable(err) {
		b.markSuccess()
	} else {
    // 异常请求计数
		b.markFailure()
	}

	return err
}

总结

调用端能够经过熔断机制进行自我保护，防止调用下游服务出现异常，或者耗时过长影响调用端的业务逻辑，不少功能完整的微服务框架都会内置熔断器。其实，不只微服务调用之间须要熔断器，在调用依赖资源的时候，好比mysql、redis等也能够引入熔断器的机制。

项目地址：
https://github.com/tal-tech/go-zero