配置

    <properties>
        <!-- 依赖版本 -->
        <hystrix.version>1.3.16</hystrix.version>
        <hystrix-metrics-event-stream.version>1.1.2</hystrix-metrics-event-stream.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.netflix.hystrix</groupId>
            <artifactId>hystrix-core</artifactId>
            <version>${hystrix.version}</version>
        </dependency>
        <dependency>
            <groupId>com.netflix.hystrix</groupId>
            <artifactId>hystrix-metrics-event-stream</artifactId>
            <version>${hystrix-metrics-event-stream.version}</version>
        </dependency>
    </dependencies>

使用

超时降级

package com.fulton_shaw;

import com.fulton_shaw.common.util.concurrent.ThreadUtils;
import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixCommandProperties;

/**
 * @author xiaohuadong
 * @date 2018/11/06
 */
public class FallbackCommand extends HystrixCommand<String> {
    public FallbackCommand(String name){
        super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey(name))
        .andCommandPropertiesDefaults(HystrixCommandProperties.Setter().withExecutionIsolationThreadTimeoutInMilliseconds(500)));

    }

    @Override
    protected String getFallback() {
        return "FALLBACK";
    }

    protected String run() throws Exception {
        ThreadUtils.sleepRandom(300,700);
        return "SUCCEED RUN";
    }
}

package com.fulton_shaw;

import com.fulton_shaw.common.util.concurrent.ExpectUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.Callable;

/**
 * @author xiaohuadong
 * @date 2018/11/06
 */
public class FallbackMain {
    private static final Logger LOG = LoggerFactory.getLogger(FallbackMain.class);
    public static void main(String[] args) {
        ExpectUtils.untilTrueCount(20, new Callable<Boolean>() {
            public Boolean call() throws Exception {
                FallbackCommand command = new FallbackCommand("will-you-fallback");

                String result = command.execute();
                LOG.info("{}", result);
                return "FALLBACK".equals(result);
            }
        });

        LOG.info("end");

        System.exit(0);

    }
}

基本设计

接口+Factory+intern构成一个Hystrix的全局注册中心
同时，将UnitTest放到类的后面，以便发布时，将测试包含在内。

很大量是依赖RxJava库，其中，Observable，Operator非常经典。
HystrixCommand运行时，是处于线程池中的。

服务场景

1.单个服务熔断：一个服务正常能够接受2个并发访问，测试4个并发访问，带有超时的场景

2.服务之间存在依赖的熔断：服务A正常接受5个并发访问，服务B接受3个并发访问，服务C接受2个并发访问，服务A依赖B，B依赖C。

单服务模式下Hystrix的使用测试

构造ThroughputService代表一般的服务，该服务能够在一定时间内返回，同时，有一个支持的最大并发量上限

package com.fulton_shaw.common.lang.testing;


import com.fulton_shaw.common.lang.FixedValueGetter;
import com.fulton_shaw.common.lang.ValueGetter;
import com.fulton_shaw.common.util.concurrent.ThreadUtils;
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.annotation.Nullable;
import javax.annotation.concurrent.ThreadSafe;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author xiaohuadong
 * @date 2018/11/08
 */
@ThreadSafe
public class ThroughPutService implements Service {
    private static final Logger LOG = LoggerFactory.getLogger(ThroughPutService.class);


    /* 服务时间 ， 单位:ms  小于等于0时，无需等待 */
    private ValueGetter<Long> serviceTimeStrategy;

    /* 最大并发数 , 小于等于0时，无限制*/
    private final int maxConcurrent;

    /* 服务调用 */
    private Runnable beforeService;
    private Runnable afterService;


    /* 服务拒绝时调用 */
    private Runnable onDeny;


    /* 服务异常时调用 */
    private Function<Exception,Void> onException;

    private AtomicInteger currentConcurrent;


  /**
     * 调用服务
     *
     * @return 服务是否成功
     */
    public boolean tryService() {
        boolean canService = false;
        LOG.debug("{} --> beginning tryService,current concurrent = {}",ThreadUtils.getCurrentThreadName(),currentConcurrent.get());
        if (maxConcurrent <= 0) {
            currentConcurrent.incrementAndGet();
            canService = true;
        } else {
            // CAS
            while (true) {
                int old = currentConcurrent.get();
                if(old >= maxConcurrent){
                    break;
                }else if(currentConcurrent.compareAndSet(old, old + 1)){
                    canService = true;
                    break;
                }
            }
        }


        try {
            if (canService) {
                LOG.debug("{} --> gain tryService,current concurrent = {}",ThreadUtils.getCurrentThreadName(),currentConcurrent.get());
                beforeService.run();
                Long sleep = serviceTimeStrategy.get();
                LOG.debug("{} --> will sleep {} ms",ThreadUtils.getCurrentThreadName(),sleep);
                ThreadUtils.sleep(sleep);
                currentConcurrent.decrementAndGet();
                afterService.run();
            } else {
                onDeny.run();
            }
        }catch (Exception e){
            try {
                onException.apply(e);
            }catch (Exception ae){
                LOG.error("error happened while handing {}",e.toString(),ae);
            }
        }


        LOG.debug("{} --> end tryService,current concurrent = {}",ThreadUtils.getCurrentThreadName(),currentConcurrent.get());

        return canService;
    }

}

ThroughPutService类的tryService方法尝试调用一个服务，如果当前并发量尚未达到上限，则服务，否则，调用onDeny。若有错误发生，则调用onException。
下面是对该Service的一个测试

public class ThroughPutServiceMain {
    public static void main(String[] args) {
        final ThroughPutService service = ThroughPutService.makeService(new RandomLongGetter(300, 500), 2);
        ThreadUtils.startThreadForTimesAndWait(5, new ProcessMethod<Integer>() {
            @Nullable
            @Override
            public void apply(@Nullable Integer input) {
                service.tryService();
            }
        });
    }

}

serivce的服务时间在300~500毫秒之间，随机返回。最大允许的并发量是2。测试程序开启了5个线程来消费这个服务，下面的结果显示，只有其中两个线程得到服务，其他均被拒绝。
得到服务的是Thread-2和Thread-3, gain tryService.
输出结果：

15:39:46.789 [Thread-2] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-2 --> beginning tryService,current concurrent = 0
15:39:46.789 [Thread-4] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-4 --> beginning tryService,current concurrent = 0
15:39:46.789 [Thread-3] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-3 --> beginning tryService,current concurrent = 0
15:39:46.789 [Thread-5] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-5 --> beginning tryService,current concurrent = 0
15:39:46.789 [Thread-1] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-1 --> beginning tryService,current concurrent = 0
15:39:46.791 [Thread-5] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-5 --> end tryService,current concurrent = 2
15:39:46.791 [Thread-3] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-3 --> gain tryService,current concurrent = 2
15:39:46.791 [Thread-2] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-2 --> gain tryService,current concurrent = 2
15:39:46.791 [Thread-1] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-1 --> end tryService,current concurrent = 2
15:39:46.791 [Thread-4] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-4 --> end tryService,current concurrent = 2
15:39:46.791 [Thread-2] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-2 --> will sleep 415 ms
15:39:46.791 [Thread-3] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-3 --> will sleep 461 ms
15:39:47.206 [Thread-2] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-2 --> end tryService,current concurrent = 1
15:39:47.252 [Thread-3] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - Thread-3 --> end tryService,current concurrent = 0

ThroughPutService不能服务的情况有一种：就是最大并发量。
但是对于客户端而言，ThroughPutService不能服务还包括一种情况：ThroughPutService本身的服务质量--响应时间超时。

HystrixCommand封装ThroughPutService

我们首先识别出ThroughPutService服务不可用的情况，就是：1.超过服务的最大并发量 2.服务本身超时
在下面的Command的封装中，run会调用service，但是service可能返回false，因此，在返回false的情况下，我们应当抛出异常，表明服务不可用，迫使Hystrix转向getFallback()调用。
此外，即使service正常可用，但是服务时间超时，Hystrix本身会对run进行超时判断，因此，它也会转向getFallback()

package com.fulton_shaw.third_party_demo.hystrix;

public class SingleServiceCommand extends HystrixCommand<Void> {
    private static final Logger LOG = LoggerFactory.getLogger(SingleServiceCommand.class);
    private ThroughPutService service;


    protected SingleServiceCommand(ThroughPutService service,long time) {
        super(HystrixCommand.Setter.
                withGroupKey(HystrixCommandGroupKey.Factory.asKey(SingleServiceCommand.class.getSimpleName()))
                .andCommandPropertiesDefaults(HystrixCommandProperties.Setter().withExecutionTimeoutEnabled(true).withExecutionTimeoutInMilliseconds((int)time))
        );
        this.service = service;
    }

    @Override
    protected Void run() throws Exception {
        boolean succeed = service.tryService();
        LOG.info("{} --> tryService succeed? {} ",ThreadUtils.getCurrentThreadName(),succeed);
        if(!succeed){
            throw  new RuntimeException(String.format("%s --> try service rejected", ThreadUtils.getCurrentThreadName()));
        }
        return null;
    }

    @Override
    protected Void getFallback() {
        LOG.info("{} --> getting Fallback",Thread.currentThread().getName());
        return null;
    }
}

测试封装的HystrixCommand

package com.fulton_shaw.third_party_demo.hystrix;

public class SingleServiceDemo {
    private static final Logger LOG = LoggerFactory.getLogger(SingleServiceDemo.class);

    public static void main(String[] args) {

        final ThroughPutService service = ThroughPutService.makeService(new RandomLongGetter(1000, 3000), 2);


        final AtomicInteger denied = new AtomicInteger(0);
        service.setOnDeny(new Runnable() {
            @Override
            public void run() {
                denied.incrementAndGet();
            }
        });

        int timeout = 2000;
        int commandCount = 4;
        final SingleServiceCommand[] commands = new SingleServiceCommand[commandCount];
        for (int i = 0; i < commandCount; i++) {
            commands[i] = new SingleServiceCommand(service,timeout);
        }

        ThreadUtils.startThreadForTimesAndWait(4, new ProcessMethod<Integer>() {
            @Nullable
            @Override
            public void apply(@Nullable Integer i) {
                commands[i].execute();
            }
        });

        LOG.info("concurrent denied = {}", denied.get());
    }
}

在上面的程序中，我们新建了一个服务，随机返回时间是1000-3000ms之间，我们将服务的超时时间设置为2000ms，然后使用denied变量记录服务被拒绝的数量。然后，我们新建了4个对该服务的调用实例，由Hystrix管理。
从下面的输出结果中，我们可以看出4和3获得服务执行，其中4超时，3没有超时，1和2均被拒绝服务。
由于1,2被拒绝服务，因此他们抛出异常之后，Hystrix转向了Fallback，我们可以看到的时，抛出异常之后，getFallback仍然处于同一线程之中。
但是4转向Fallback之后，却是由HystrixTimer-1来调用的，而原来的线程仍然继续运行，我们可以看到4最后也输出了 end tryService.
输出结果：

16:22:04.243 [hystrix-SingleServiceCommand-4] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - hystrix-SingleServiceCommand-4 --> beginning tryService,current concurrent = 0
16:22:04.244 [hystrix-SingleServiceCommand-4] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - hystrix-SingleServiceCommand-4 --> gain tryService,current concurrent = 1
16:22:04.243 [hystrix-SingleServiceCommand-3] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - hystrix-SingleServiceCommand-3 --> beginning tryService,current concurrent = 0
16:22:04.244 [hystrix-SingleServiceCommand-4] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - hystrix-SingleServiceCommand-4 --> will sleep 2665 ms
16:22:04.244 [hystrix-SingleServiceCommand-3] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - hystrix-SingleServiceCommand-3 --> gain tryService,current concurrent = 2
16:22:04.244 [hystrix-SingleServiceCommand-3] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - hystrix-SingleServiceCommand-3 --> will sleep 1284 ms
16:22:04.244 [hystrix-SingleServiceCommand-1] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - hystrix-SingleServiceCommand-1 --> beginning tryService,current concurrent = 2
16:22:04.244 [hystrix-SingleServiceCommand-1] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - hystrix-SingleServiceCommand-1 --> end tryService,current concurrent = 2
16:22:04.244 [hystrix-SingleServiceCommand-1] INFO  com.fulton_shaw.third_party_demo.hystrix.SingleServiceCommand - hystrix-SingleServiceCommand-1 --> tryService succeed? false
16:22:04.244 [hystrix-SingleServiceCommand-2] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - hystrix-SingleServiceCommand-2 --> beginning tryService,current concurrent = 2
16:22:04.244 [hystrix-SingleServiceCommand-2] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - hystrix-SingleServiceCommand-2 --> end tryService,current concurrent = 2
16:22:04.244 [hystrix-SingleServiceCommand-2] INFO  com.fulton_shaw.third_party_demo.hystrix.SingleServiceCommand - hystrix-SingleServiceCommand-2 --> tryService succeed? false
16:22:04.245 [hystrix-SingleServiceCommand-1] DEBUG com.netflix.hystrix.AbstractCommand - Error executing HystrixCommand.run(). Proceeding to fallback logic ...
java.lang.RuntimeException: hystrix-SingleServiceCommand-1 --> try service rejected
at com.fulton_shaw.third_party_demo.hystrix.SingleServiceCommand.run(SingleServiceCommand.java:34) ~[classes/:?]
...
16:22:04.245 [hystrix-SingleServiceCommand-2] DEBUG com.netflix.hystrix.AbstractCommand - Error executing HystrixCommand.run(). Proceeding to fallback logic ...
java.lang.RuntimeException: hystrix-SingleServiceCommand-2 --> try service rejected
at com.fulton_shaw.third_party_demo.hystrix.SingleServiceCommand.run(SingleServiceCommand.java:34) ~[classes/:?]
...
16:22:04.254 [hystrix-SingleServiceCommand-2] INFO  com.fulton_shaw.third_party_demo.hystrix.SingleServiceCommand - hystrix-SingleServiceCommand-2 --> getting Fallback
16:22:04.257 [hystrix-SingleServiceCommand-1] INFO  com.fulton_shaw.third_party_demo.hystrix.SingleServiceCommand - hystrix-SingleServiceCommand-1 --> getting Fallback
16:22:05.528 [hystrix-SingleServiceCommand-3] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - hystrix-SingleServiceCommand-3 --> end tryService,current concurrent = 1
16:22:05.528 [hystrix-SingleServiceCommand-3] INFO  com.fulton_shaw.third_party_demo.hystrix.SingleServiceCommand - hystrix-SingleServiceCommand-3 --> tryService succeed? true
16:22:06.231 [hystrix-SingleServiceCommand-4] DEBUG com.fulton_shaw.common.lang.testing.ThroughPutService - hystrix-SingleServiceCommand-4 --> end tryService,current concurrent = 0
16:22:06.231 [hystrix-SingleServiceCommand-4] INFO  com.fulton_shaw.third_party_demo.hystrix.SingleServiceCommand - hystrix-SingleServiceCommand-4 --> tryService succeed? true
16:22:06.232 [HystrixTimer-1] INFO  com.fulton_shaw.third_party_demo.hystrix.SingleServiceCommand - HystrixTimer-1 --> getting Fallback
16:22:06.233 [main] INFO  com.fulton_shaw.third_party_demo.hystrix.SingleServiceDemo - concurrent denied = 2

多服务和服务存在依赖的场景测试

2.服务之间存在依赖的熔断：服务A正常接受5个并发访问，服务B接受3个并发访问，服务C接受2个并发访问，服务A依赖B，B依赖C。
只需要将服务

参考

https://www.jianshu.com/p/fc19f6ed6d0d

https://www.jianshu.com/p/05f3e75b3739

Hystrix中的设计哲学

Hystrix使用总结

execute方法会开启新的线程执行，当前线程阻塞等待那个线程。
所谓信号量隔离，是指当服务并发量大于信号量设定的值时，自动降级
熔断是指降级的终极情况，

• 假设线路内的容量（请求QPS）达到一定阈值（通过 HystrixCommandProperties.circuitBreakerRequestVolumeThreshold() 配置）
• 同时，假设线路内的错误率达到一定阈值（通过 HystrixCommandProperties.circuitBreakerErrorThresholdPercentage() 配置）
• 熔断器将从『闭路』转换成『开路』
• 若此时是『开路』状态，熔断器将短路后续所有经过该熔断器的请求，这些请求直接走『失败回退逻辑』
• 经过一定时间（即『休眠窗口』，通过 HystrixCommandProperties.circuitBreakerSleepWindowInMilliseconds() 配置），后续第一个请求将会被允许通过熔断器（此时熔断器处于『半开』状态），若该请求失败，熔断器将又进入『开路』状态，且在休眠窗口内保持此状态；若该请求成功，熔断器将进入『闭路』状态，回到逻辑1循环往复。

其他特性

缓存
组合请求
Dashboard监控