Hystrix断路器的原理

上篇文章我主要讲的是官方文档对Hystrix的说明，阐述了在微服中Hystrix担任的角色，以及它是如何达到这样的作用的。当然具体如何使用Hystrix我并没有详细说明，因为网上关于Hystrix的使用的教程网上已经很多了，大家随便百度一下就能找到，这篇文章主要是能帮助大家更深入的理解Hystrix的实现原理。

我对Hystrix的理解是，它的核心其实就两个，一个是"断路器" ，另一个是"依赖隔离"，能把这两个核心理解透，就把Hystrix理解透了。"依赖隔离"后面如果有时间我们再讲，今天我们先来说说"断路器"的原理。如果对Hystrix的概念比较陌生，可以先看看这边文章Hystrix的正确理解方式

首先我们肯定先去看官方文档，先别一脑袋扎进源码里这样很难找到重点，正确的方式是根据官方文档的说明再结合源码这样才能最高效的找到我们需要找到东西。官方文档关于”断路器“原理的说明在这 https://github.com/Netflix/Hystrix/wiki/How-it-Works,下图是官方文档中对”熔断器“原理说明的流程图。

circuit-breaker-640.png

看到这个流程图可能会有点蒙，不急，我们先来看看文档中对这张流程图的说明：

The following diagram shows how aHystrixCommand orHystrixObservableCommandinteracts with aHystrixCircuitBreaker and its flow of logic and decision-making, including how the counters behave in the circuit breaker

下面的流程图展示的是HystrixCommand或HystrixObservableCommand与HystrixCircuitBreaker之间是如何交互的，以及其中的逻辑流程和判断逻辑，还包括计数器在熔断器的中作用。

上面是文档中的原始内容，下面是我的翻译，再Hystrix的正确理解方式这边文章中我说过，Hystrix的实现使用的设计模式是”命令模式“，再Hystrix中微服请求依赖的微服是通过HystrixCommand或是HystrixObservableCommand实现的，所以“断路”和“隔离”逻辑其实就是在Command中实现的，而上面提到的HystrixCircuitBreaker就是正真实现”断路器“逻辑的类。所以我们把HystrixCircuitBreaker搞明白了就明白了”断路器“的原理。下面我们就根据HystrixCircuitBreaker源码和上面的流程图来说说”断路器“中的逻辑（具体的说明我写在下面代码的注释中）。

HystrixCircuitBreaker

 /**
 * 熔断逻辑挂在HystrixCommand中执行如果请求失败次数超过规定的阀值，它将会定制请求的执行。开启熔断后，
 * 它允许在一段时间的休眠后执行一次请求，如果请求成功则关闭熔断器，网络请求被执行。 
 */public interface HystrixCircuitBreaker {    /**
     * 每个Hystrix命令的请求都通过这个方法判断是否执行请求
     */
    boolean allowRequest();    /**
     * 返回当前断路器是否打开的状态
     */
    boolean isOpen();    /**
     * 处于半开状态时，如果尝试请求成功，就调用这个方法（断路器关闭在这个方法实现的）
     */
    void markSuccess();    /**
     * 处于半开状态时，如果尝试请求成功，就调用这个方法（断路器开启在这个方法实现的）
     */
    void markNonSuccess();    /**
     * 在命令执行开始时调用以尝试执行。 这是非幂等的 - 它可能会修改内部
     */
    boolean attemptExecution();

HystrixCircuitBreaker是一个抽象接口，包含上面5个抽象方法，其实并不复杂。
HystrixCircuitBreaker中还包含3个内部类分别是：

1. Factory

   //这个里面存放的是ConcurrentHashMap<String, HystrixCircuitBreaker> ,看到这个接口大
    //家应该能够知道这个类使用来作什么的了，没错它就是用来管理这个微服务中所有断路
    //器的工厂，每个依赖其他微服的接口都需要有对应的断路器。
    class Factory{
          //代码省略
    }

2. HystrixCircuitBreakerImpl

断路器接口HystrixCircuitBreaker的实现类，断路器的主要业务逻辑都在这。

/* package */class HystrixCircuitBreakerImpl implements HystrixCircuitBreaker {    //断路器相关的配置参数
    private final HystrixCommandProperties properties;
    断路器最核心的东西，通过时间窗的形式，记录一段时间范围内（默认是10秒）的接口请求的健康状况，
    并得到对应的度量指标（请求次数，错误率），如果这个指标不符合条件则断路器打开。这块逻辑比较复杂
    这里就不细说，想了解具体如何实现的可以看看对应的源码。    private final HystrixCommandMetrics metrics;

    断路器的三个状态 ：OPEN  CLOSED 没什么好讲的，主要是这个HALF_OPEN状态，这个状态在什么情况下出现呢，
    当断路器打开后，对应接口的请求会有段休眠期，这个休眠期内接口请求不会被正真的执行，但是如果休眠期时间过了，
    这个时候断路器的状态就到了HALF_OPEN状态，这个时候断路器允许一次真实的接口请求，如果这次请求失败，则断路
    器打开（OPEN），循环上面的动作，如果请求成功则断路器关闭（CLOSED）。    enum Status {
        CLOSED, OPEN, HALF_OPEN;
    }
    
    记录断路器的状态，默认是关闭的    private final AtomicReference<Status> status = new AtomicReference<Status>(Status.CLOSED);
    记录最近一次断路器开启的时间，用于判断休眠期的结束时间    private final AtomicLong circuitOpened = new AtomicLong(-1);
    这个是通过Rxjava实现的对HystrixCommandMetrics结果的观察者对象，当HystrixCommandMetrics值发生变化时会通知观察者。    private final AtomicReference<Subscription> activeSubscription = new AtomicReference<Subscription>(null);    protected HystrixCircuitBreakerImpl(HystrixCommandKey key, HystrixCommandGroupKey commandGroup, final HystrixCommandProperties properties, HystrixCommandMetrics metrics) {        this.properties = properties;        this.metrics = metrics;        //On a timer, this will set the circuit between OPEN/CLOSED as command executions occur
        Subscription s = subscribeToStream();
        activeSubscription.set(s);
    }    private Subscription subscribeToStream() {        /*
         * This stream will recalculate the OPEN/CLOSED status on every onNext from the health stream
         */
        return metrics.getHealthCountsStream()
                .observe()
                .subscribe(new Subscriber<HealthCounts>() {                    @Override
                    public void onCompleted() {

                    }                    @Override
                    public void onError(Throwable e) {

                    }
  这个就是上面说的观察者，当HystrixCommandMetrics的度量指标发生变化时，观察者实现的业务逻辑                    @Override
                    public void onNext(HealthCounts hc) {
                        首先校验的时在时间窗范围内的请求次数，如果低于阈值（默认是20），不做处理，如果高于阈值，则去判断接口请求的错误率                        if (hc.getTotalRequests() < properties.circuitBreakerRequestVolumeThreshold().get()) {                            // we are not past the minimum volume threshold for the stat window,
                            // so no change to circuit status.
                            // if it was CLOSED, it stays CLOSED
                            // if it was half-open, we need to wait for a successful command execution
                            // if it was open, we need to wait for sleep window to elapse
                        } else {
                      判断接口请求的错误率（阈值默认是50），如果高于这个值，则断路器打开                            if (hc.getErrorPercentage() < properties.circuitBreakerErrorThresholdPercentage().get()) {                                //we are not past the minimum error threshold for the stat window,
                                // so no change to circuit status.
                                // if it was CLOSED, it stays CLOSED
                                // if it was half-open, we need to wait for a successful command execution
                                // if it was open, we need to wait for sleep window to elapse
                            } else {
                               打开断路器，同时记录断路器开启时间                                if (status.compareAndSet(Status.CLOSED, Status.OPEN)) {
                                    circuitOpened.set(System.currentTimeMillis());
                                }
                            }
                        }
                    }
                });
    }
    
    半开状态，尝试请求接口成功    @Override
    public void markSuccess() {
        关闭断路器        if (status.compareAndSet(Status.HALF_OPEN, Status.CLOSED)) {
            重置时间窗健康度量指标
            metrics.resetStream();
            Subscription previousSubscription = activeSubscription.get();
            注销观察者            if (previousSubscription != null) {
                previousSubscription.unsubscribe();
            }
            设置新的观察者
            Subscription newSubscription = subscribeToStream();
            activeSubscription.set(newSubscription);
            还原断路器开启时间
            circuitOpened.set(-1L);
        }
    }
    
    半开状态，尝试请求接口失败    @Override
    public void markNonSuccess() {
        断路器打开        if (status.compareAndSet(Status.HALF_OPEN, Status.OPEN)) {
           更新最新的断路器开启时间
            circuitOpened.set(System.currentTimeMillis());
        }
    }    @Override
    public boolean isOpen() {
       强制开启断路器        if (properties.circuitBreakerForceOpen().get()) {            return true;
        }
       强制关闭断路器（断路器可以通过配置强制关闭或开启）        if (properties.circuitBreakerForceClosed().get()) {            return false;
        }
        根据断路器开启时间判断断路器的开启状态        return circuitOpened.get() >= 0;
    }
    
    判断是否允许请求接口（每次请求接口都会判断）    @Override
    public boolean allowRequest() {        if (properties.circuitBreakerForceOpen().get()) {            return false;
        }        if (properties.circuitBreakerForceClosed().get()) {            return true;
        }        if (circuitOpened.get() == -1) {            return true;
        } else {            if (status.get().equals(Status.HALF_OPEN)) {                return false;
            } else {                return isAfterSleepWindow();
            }
        }
    }

    判断时间有没有过休眠期    private boolean isAfterSleepWindow() {        final long circuitOpenTime = circuitOpened.get();        final long currentTime = System.currentTimeMillis();        final long sleepWindowTime = properties.circuitBreakerSleepWindowInMilliseconds().get();        return currentTime > circuitOpenTime + sleepWindowTime;
    }

    尝试执行接口请求    @Override
    public boolean attemptExecution() {        if (properties.circuitBreakerForceOpen().get()) {            return false;
        }        if (properties.circuitBreakerForceClosed().get()) {            return true;
        }        if (circuitOpened.get() == -1) {            return true;
        } else {            if (isAfterSleepWindow()) {                if (status.compareAndSet(Status.OPEN, Status.HALF_OPEN)) {                    //only the first request after sleep window should execute
                    return true;
                } else {                    return false;
                }
            } else {                return false;
            }
        }
    }
}

在上面的代码中的注释应该就能理解断路器整体的实现逻辑了。

3.NoOpCircuitBreaker

什么都没做的HystrixCircuitBreaker实现，允许所有请求，断路器始终是关闭的。

    /* package */static class NoOpCircuitBreaker implements HystrixCircuitBreaker {    @Override
    public boolean allowRequest() {        return true;
    }    @Override
    public boolean isOpen() {        return false;
    }    @Override
    public void markSuccess() {

    }    @Override
    public void markNonSuccess() {

    }    @Override
    public boolean attemptExecution() {        return true;
    }
}

总结

这篇文章从源码角度解释了Hystrix断路器的原理，看完HystrixCircuitBreaker的逻辑后，再去看文章开始贴的那张断路器的流程图，就能很好的理解这个流程了。希望这篇文章能对大家有所帮助，欢迎点赞大赏！文章中有错误的地方欢迎评论指出。

作者：瘦竹竿
链接：https://www.jianshu.com/p/0df57cb1b7fb