golang 熔断器的实现过程

type CircuitBreaker struct {  
  name          string  
  maxRequests   uint32  // 最大请求数 （半开启状态会限流）  
  interval      time.Duration   // 统计周期  
  timeout       time.Duration   // 进入熔断后的超时时间  
  readyToTrip   func(counts Counts) bool // 通过 Counts 判断是否开启熔断。需要自定义  
  onStateChange func(name string, from State, to State) // 状态修改时的钩子函数  

  mutex      sync.Mutex // 互斥锁，下面数据的更新都需要加锁  
  state      State  // 记录了当前的状态  
  generation uint64 // 标记属于哪个周期  
  counts     Counts // 计数器，统计了 成功、失败、连续成功、连续失败等，用于决策是否进入熔断  
  expiry     time.Time // 进入下个周期的时间  
}  

// 熔断器的调用  
func (cb *CircuitBreaker) Execute(req func() (interface{}, error)) (interface{}, error) {  

  // ①请求之前的判断  
  generation, err := cb.beforeRequest()  
  if err != nil {  
    return nil, err  
  }  

  defer func() {  
    e := recover()  
    if e != nil {  
      // ③ panic 的捕获  
      cb.afterRequest(generation, false)  
      panic(e)  
    }  
  }()  

  // ② 请求和执行  
  result, err := req()  

  // ③ 更新计数  
  cb.afterRequest(generation, err == nil)  
  return result, err  
}  

func (cb *CircuitBreaker) beforeRequest() (uint64, error) {  
  cb.mutex.Lock()  
  defer cb.mutex.Unlock()  

  now := time.Now()  
  state, generation := cb.currentState(now)  

  if state == StateOpen { // 熔断器开启，直接返回  
    return generation, ErrOpenState  
  } else if state == StateHalfOpen && cb.counts.Requests >= cb.maxRequests { // 如果是半打开的状态，并且请求次数过多了，则直接返回  
    return generation, ErrTooManyRequests  
  }  

  cb.counts.onRequest()  
  return generation, nil  
}  

func (cb *CircuitBreaker) currentState(now time.Time) (State, uint64) {  
  switch cb.state {  
  case StateClosed:  
    if !cb.expiry.IsZero() && cb.expiry.Before(now) { // 是否需要进入下一个计数周期  
      cb.toNewGeneration(now)  
    }  
  case StateOpen:  
    if cb.expiry.Before(now) {  
      // 熔断器由开启变更为半开  
      cb.setState(StateHalfOpen, now)  
    }  
  }  
  return cb.state, cb.generation  
}  

func (cb *CircuitBreaker) afterRequest(before uint64, success bool) {  
  cb.mutex.Lock()  
  defer cb.mutex.Unlock()  

  now := time.Now()  

  // 如果不在一个周期，就不再计数  
  state, generation := cb.currentState(now)  
  if generation != before {  
    return  
  }  

  if success {  
    cb.onSuccess(state, now)  
  } else {  
    cb.onFailure(state, now)  
  }  
}