err := hystrix.Do("test", func() error {  
    // do something
    return nil  
}, func(err error) error {  
    fmt.Println(err.Error())  
    return err  
})

type (  
    metrics struct {  
        total *number  
        success *number  
        fail *number  
    }  
    number struct {  
        buckets [10]*bucket  
        mutex sync.RWMutex  
    }  
    bucket struct {  
        timestamp int64  
        value float64  
    }  
)

func (number *number) increment(now int64) {  
    index := now % 10  
    number.mutex.RLock()  
    if now < number.buckets[index].timestamp {  
        number.mutex.RUnlock()  
        return  
    }  
    number.mutex.RUnlock()  
    number.mutex.Lock()  
    defer number.mutex.Unlock()  
    if number.buckets[index].timestamp != now {  
        number.buckets[index].value = 0  
    }  
    number.buckets[index].timestamp = now  
    number.buckets[index].value++  
}

func (number *number) sum() (sum float64) {  
    number.mutex.RLock()  
    defer number.mutex.RUnlock()  
    now := time.Now().Unix()  
    for _, ele := range number.buckets {  
        if ele.timestamp <= now-10 {  
            continue  
        }  
        sum += ele.value  
    }  
    return  
}

type Circuit struct {  
    Timeout time.Duration  
    RequestVolumeThreshold int // 達(dá)到這個請求數(shù)量后才去判斷是否要開啟熔斷  
    ErrorPercentThreshold int // 請求數(shù)量大于等于 RequestVolumeThreshold 并且錯誤率到達(dá)這個百分比后就會啟動熔斷  
    SleepWindow int // 熔斷器被打開后 SleepWindow 的時間就是控制過多久后去嘗試服務(wù)是否可用了 單位為毫秒  
    open bool  
    lastOpenTime int64 // 單位ms  
    mutex sync.RWMutex  
    metric *metrics  
}
func (circuit *Circuit) isHealthy() bool {  
    // 當(dāng)前總請求量小于設(shè)置的閾值 返回
    if int(circuit.metric.totalRequest()) < circuit.RequestVolumeThreshold {  
        return true  
    }  
    // 判斷錯誤率是否大于設(shè)定的閾值，從而判斷目標(biāo)服務(wù)是否出現(xiàn)故障
    return circuit.metric.errorPercent() < circuit.ErrorPercentThreshold  
}
func (circuit *Circuit) isOpen() bool {  
    circuit.mutex.RLock()  
    o := circuit.open  
    circuit.mutex.RUnlock()  
    if !o {  
        return false  
    }  
    // 當(dāng)前時間與熔斷器打開時間進(jìn)行對比，如果過了時間窗口，那么恢復(fù)。
    if circuit.lastOpenTime+int64(circuit.SleepWindow) < time.Now().UnixMilli() {  
        circuit.setClose()  
        return false  
    }  
    return true  
}  
func (circuit *Circuit) setClose() {  
    circuit.mutex.Lock()  
    defer circuit.mutex.Unlock()  
    if !circuit.open {  
        return  
    }  
    circuit.open = false  
    // 清空指標(biāo)數(shù)據(jù) 重新計(jì)算
    circuit.metric.clear()  
}

func (cmd *command) do() error {  
    defer cmd.reportAllEvents()  
    // 判斷熔斷器是否打開
    if !cmd.circuit.allowRequest() {  
        cmd.report(circuitOpenEvent)  
        return cmd.tryFallback(ErrCircuitOpen)  
    }  
    // 設(shè)置超時時間
    timer := time.NewTimer(cmd.circuit.Timeout)  
    defer timer.Stop()  
    finish, errCh := make(chan struct{}), make(chan error)  
    go func() {  
        if err := cmd.run(); err != nil {  
            errCh <- err  
            return  
        }  
        finish <- struct{}{}  
    }()  
    // 處理 超時、執(zhí)行成功、執(zhí)行失敗 這三種情況
    // 超時以及執(zhí)行失敗都認(rèn)為錯誤，降級處理
    select {  
    case <-timer.C:  
        return cmd.tryFallback(ErrTimeout)   
    case <-finish:  
        cmd.report(successEvent)  
        return nil  
    case err := <-errCh:  
        return cmd.tryFallback(err)  
    }  
}