Hystrix实现分布式系统中的故障容错

2018-04-04 17:50:39 浏览数 (1)

Hystrix是什么

分布式服务系统通常会通过HTTP或RPC方式调用所依赖的服务，例如支付服务通过HTTP或RPC调用银行卡服务。在高并发请求的情景下，依赖的服务可能会出现服务异常、网络连接缓慢、资源繁忙、暂时不可用、服务脱机等情况，这些异常情况将会严重影响整个线上系统的稳定性和可用性，最糟糕的情况是产生服务雪崩效应。复杂的分布式服务系统往往会依赖更多的其它服务，在高并发的情况下，如果没有做好隔离措施，这些依赖将会拖垮整个服务调用者。Hystrix是Netflix的一个帮助解决分布式服务系统交互时超时处理和容错的类库，它具有降级和熔断的保护能力，可以优雅的解决上述问题。

Hystrix能做什么

Hystrix提供了如下功能特性：

  1. Hystrix把服务调用统称为依赖调用，Hystrix通过使用命令模式将依赖调用逻辑封装在HystrixCommand中，每一次的依赖调用将在Hystrix的单独线程池(或信号)中执行；
  2. 可根据业务需要配置依赖分组名、线程池，使不同分组的依赖可以在不同的线程池中执行，隔离不同依赖调用的资源；
  3. 可配置依赖调用超时时间(一般配置为比99.5%平均调用时间略高)，当依赖调用超时时直接返回或执行getFallback方法；
  4. 依赖调用异常、超时、短路时将执行getFallback方法；
  5. 提供了熔断器(CircuitBreaker)机制，可根据设定的条件(如调用失败率大于50%)判断依赖调用是否可以继续被调用，如果某个依赖调用的错误百分比超过阈值，则通过手动或自动地中断一个熔断器，一段时间内依赖调用无法被执行；
  6. 提供了对依赖调用的实时统计和监控。

Hystrix如何使用

1.添加Hystrix依赖

<dependency> <groupId>com.netflix.hystrix</groupId> <artifactId>hystrix-core</artifactId> <version>1.5.12</version> </dependency>

2.使用HystrixCommand封装依赖调用

通过继承HystrixCommand封装依赖调用，示例代码如下：

public class CommandHelloWorld extends HystrixCommand<String> { private final String name; public CommandHelloWorld(String name) { super(HystrixCommandGroupKey.Factory.asKey("HelloWorldGroup")); this.name = name; } @Override protected String run() throws Exception { // 在这里调用依赖 Thread.sleep(500L); return "Hello " name "--" Thread.currentThread().getId(); } // 超时、异常后执行该方法 @Override protected String getFallback() { return "fallback"; } }

run方法：run方法体中进行依赖调用。

getFallback方法：当run方法中依赖调用超时、异常(除了HystrixBadRequestException)时会执行getFallback方法快速返回；当run方法中的依赖调用在设置的时间内超时、异常(除了HystrixBadRequestException)的频率超过阈值，后续对这个依赖的调用将直接执行getFallback方法，待冷却一段时间后，对这个依赖的调用会重新进入run方法执行。

3.执行封装的依赖调用

  • 同步执行

调用execute方法即为同步执行，当前线程将一直阻塞，直到获取结果，示例代码如下：

@Test public void testSynchronous() { CommandHelloWorld commandHelloWorld = new CommandHelloWorld("jack"); System.out.print(commandHelloWorld.execute() "--" Thread.currentThread().getId()); }

输出结果如下：

Hello jack--16--1

从输出结果可以看到依赖调用线程和主线程不是同一个，实现了线程隔离。

HystrixCommand默认的调用超时时间是1000毫秒，如果将上述run方法中的线程休眠时间改成1100毫秒，再次运行testSynchronous单元测试，将得到如下结果：

fallback--1

可以看到在依赖调用时间超过设置的默认超时时间时，将执行getFallback方法快速返回，实现优雅降级，其过程如下图所示。

  • 异步执行

调用queue方法即为异步执行，不阻塞当前线程，返回一个Future对象，示例代码如下：

@Test public void testAsynchronous() throws Exception { CommandHelloWorld commandHelloWorld = new CommandHelloWorld("jack"); Future<String> future = commandHelloWorld.queue(); System.out.println(future.get() "--" Thread.currentThread().getId()); }

输出结果如下：

Hello jack--16--1

queue().get()等同于同步调用execute()

  • 热注册观察者执行

调用observe方法即为热注册观察者执行，返回一个Observable对象，当run方法执行完成后，进入观察者订阅的事件中，示例代码如下：

@Test public void testHotObservable() throws Exception { CommandHelloWorld commandHelloWorld = new CommandHelloWorld("jack"); Observable<String> ho = commandHelloWorld.observe(); //订阅结果回调事件 ho.subscribe(new Action1<String>() { public void call(String result) { //result为run方法执行返回的结果 System.out.println(result "--" Thread.currentThread().getId()); } }); Thread.sleep(1000); //订阅一个完整的回调事件 ho.subscribe(new Subscriber<String>() { //在onNext执行后执行 public void onCompleted() { System.out.println("oonCompleted "); } //在run/onNext方法执行异常后执行 public void onError(Throwable throwable) { } //在run方法返回结果后执行 public void onNext(String s) { System.out.println("onNext: " s ); } }); }

输出结果如下：

Hello jack--16--16 onNext: Hello jack--16 oonCompleted

  • 冷注册观察者执行

调用toObservable方法即为冷注册观察者执行，同样返回Observable对象，但它是在注册的时即执行run方法，示例代码如下：

@Test public void testColdObservable() throws Exception { CommandHelloWorld commandHelloWorld = new CommandHelloWorld("jack"); Observable<String> ho = commandHelloWorld.toObservable(); ho.subscribe(new Action1<String>() { public void call(String s) { System.out.println(s "--" Thread.currentThread().getId()); } }); Thread.sleep(1000); }

输出结果如下：

Hello jack--16--16

前面三种调用方式，最终都是依赖toObservable方式，这其中的转换如下图所示：

属性配置

查看HystrixCommand源码，可以发现一个常用的构造方法HystrixCommand(HystrixCommand.Setter setter)，使用方法如下：

HystrixCommandGroupKey groupKey = HystrixCommandGroupKey.Factory.asKey("HelloWorld"); HystrixCommandKey commandKey = HystrixCommandKey.Factory.asKey("hello"); HystrixThreadPoolKey threadPoolKey = HystrixThreadPoolKey.Factory.asKey("hello"); HystrixCommand.Setter setter = HystrixCommand.Setter .withGroupKey(groupKey) .andCommandKey(commandKey) .andThreadPoolKey(threadPoolKey); HystrixCommand<String> helloCommand = new HystrixCommand<String>(setter) { protected String run() throws Exception { //依赖调用 return "run"; } @Override protected String getFallback() { //fail back return super.getFallback(); } };

这个HystrixCommand.Setter中包含了如下属性：

protected final HystrixCommandGroupKey groupKey; protected HystrixCommandKey commandKey; protected HystrixThreadPoolKey threadPoolKey; protected com.netflix.hystrix.HystrixCommandProperties.Setter commandPropertiesDefaults; protected com.netflix.hystrix.HystrixThreadPoolProperties.Setter threadPoolPropertiesDefaults;

  • HystrixCommandKey

Hystrix使用单例模式存储HystrixCommand，熔断机制就是根据单实例上的调用情况统计实现的，所以每个HystrixCommand要有自己的名字，用于区分，同时用于依赖调用的隔离。HystrixCommandKey就是用于定义这个名字，如果没有定义这个名字，Hystrix会使用其类名作为其名字，可以使用HystrixCommandKey.Factory.asKey(String name)方法定义一个名称。

  • HystrixThreadPoolKey

HystrixThreadPoolKey是HystrixCommand所在的线程池，如果该参数不设置则使用HystrixCommandGroupKey作为HystrixThreadPoolKey，这种情况下同一个HystrixCommandGroupKey下的依赖调用共用同一个线程池内，如果不想共用同一个线程池，则需要设置该参数。可以使用HystrixThreadPoolKey.Factory.asKey(String name)方法设置。

  • HystrixCommandGroupKey

Hystrix需要对HystrixCommand进行分组，便于统计、管理，所以需要一个分组名称，HystrixCommandGroupKey就是用于定义分组名称，可以使用HystrixCommandGroupKey.Factory.asKey(String name)方法定义一个分组名。每个HystrixCommand必须要配置一个分组名，一个是用于分组，还有如果没有配置HystrixThreadPoolKey，这个分组名将会用于线程池名。

  • HystrixThreadPoolProperties

从名称上可以看出这是线程池的属性配置，可以通过它设置核心线程数大小、最大线程数、任务队列大小等，当然它也又一些默认的配置参数。

  • HystrixCommandProperties

这个就是HystrixCommand的属性配置，它可以设置熔断器是否可用、熔断器熔断的错误百分比、依赖调用超时时间等，它有一些默认的配置参数，如熔断器熔断的错误百分比默认值是50%、依赖调用超时时间默认值是1000毫秒。

隔离方式

Hystrix支持线程隔离和信号量隔离：

  • 线程隔离

不同的依赖调用分配到不同的线程池中执行，使用线程对依赖调用进行隔离，上述的示例代码就是使用线程隔离。优点是隔离性能好，可设置短路机制(依赖调用失败后执行getFallback()或依赖调用熔断后，一段时间内对该依赖的调用将直接返回失败)，缺点是涉及到线程切换的性能损耗，但是官方给出的结果是性能损耗是可以接受的。

  • 信号量隔离

信号量隔离可实现对依赖调用最高并发请求数的限制，每次依赖调用都会先判断信号量是否达到阈值，如果达到极限值则拒绝调用，优点是不用新启线程，缺点是每次都需要获取信号量，使用方式如下：

HystrixCommandGroupKey groupKey = HystrixCommandGroupKey.Factory.asKey("HelloWorld"); HystrixCommandKey commandKey = HystrixCommandKey.Factory.asKey("hello"); HystrixThreadPoolKey threadPoolKey = HystrixThreadPoolKey.Factory.asKey("hello"); //配置信号量隔离 HystrixCommandProperties.Setter commandPropertiesSetter = HystrixCommandProperties.Setter().withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.SEMAPHORE); HystrixCommand.Setter setter = HystrixCommand.Setter .withGroupKey(groupKey) .andCommandKey(commandKey) .andThreadPoolKey(threadPoolKey) .andCommandPropertiesDefaults(commandPropertiesSetter);

Hystrix工作过程

工程过程如下图所示：

步骤描述如下：

  1. 使用HystrixCommand或HystrixObservableCommand封装一个依赖调用；
  2. 执行封装的依赖调用；
  3. 判断本次调用是否可以从缓存中取结果，如果可以，直接返回缓存的结果；如果不可以进入第4步判断；
  4. 判断熔断器是否打开，如果打开则进入第8步；如果没打开则进入第5步；
  5. 判断信号量或线程池是否已满，如果已满则进入第8步；如果没满则进入第6步；
  6. 执行依赖调用，调用失败或超时进入第8步；调用成功返回结果；
  7. 根据依赖调用成功、失败或超时计算熔断值；
  8. getFallback()执行失败或没实现getFallback()方法，将抛出异常；getFallback()执行成功返回fallback值。

Hystrix熔断保护机制

Hystrix熔断保护就像电路中的熔断器一样，在电压过高时，保险丝会熔断，防止火灾，做到用电安全。熔断保护机制的工作过程如下图所示：

熔断器工作过程如下：

  1. 假设大量的请求数量超过了HystrixCommandProperties.circuitBreakerRequestVolumeThreshold()的阈值，并且依赖调用失败的百分比超过了HystrixCommandProperties.circuitBreakerErrorThresholdPercentage()的阈值，熔断器将会从关闭状态变成打开状态；
  2. 在熔断器处于打开状态的期间，所有对这个依赖进行的调用都会短路，即不进行真正的依赖调用，返回失败；
  3. 在等待(冷却)的时间超过HystrixCommandProperties.circuitBreakerSleepWindowInMilliseconds()的值后，熔断器将处于半开的状态，将允许单个请求去调用依赖，如果这次的依赖调用还是失败，熔断器状态将再次变成打开，这个打开状态持续时间是HystrixCommandProperties.circuitBreakerSleepWindowInMilliseconds()配置的值；如果这次的依赖调用成功，熔断器状态将变成关闭，后续依赖调用可正常执行。

依赖调用监控

Hystrix提供了Hystrix Dashboard功能，可以实时监控依赖的调用情况。

分布式 系统架构

0 人点赞