vlambda博客
学习文章列表

服务隔离神器-Hystrix

一:为什么需要Hystrix?

在大中型分布式系统中,通常系统很多依赖(HTTP,hession,Netty,Dubbo等),如下图:

 

在高并发访问下,这些依赖的稳定性与否对系统的影响非常大,但是依赖有很多不可控问题:如网络连接缓慢,资源繁忙,暂时不可用,服务脱机等.

如下图:QPS为50的依赖 I 出现不可用,但是其他依赖仍然可用.

服务隔离神器-Hystrix

 

当依赖I 阻塞时,大多数服务器的线程池就出现阻塞(BLOCK),影响整个线上服务的稳定性.如下图:

服务隔离神器-Hystrix

 

在复杂的分布式架构的应用程序有很多的依赖,都会不可避免地在某些时候失败。高并发的依赖失败时如果没有隔离措施,当前应用服务就有被拖垮的风险。

 

Java代码  

  1. 例如:一个依赖30个SOA服务的系统,每个服务99.99%可用。  

  2. 99.99%的30次方 ≈ 99.7%  

  3. 0.3% 意味着一亿次请求 会有 3,000,00次失败  

  4. 换算成时间大约每月有2个小时服务不稳定.  

  5. 随着服务依赖数量的变多,服务不稳定的概率会成指数性提高.  


 解决问题方案:对依赖做隔离,Hystrix就是处理依赖隔离的框架,同时也是可以帮我们做依赖服务的治理和监控.


1:Hystrix使用命令模式HystrixCommand(Command)包装依赖调用逻辑,每个命令在单独线程中/信号授权下执行。

2:可配置依赖调用超时时间,超时时间一般设为比99.5%平均时间略高即可.当调用超时时,直接返回或执行fallback逻辑。

3:为每个依赖提供一个小的线程池(或信号),如果线程池已满调用将被立即拒绝,默认不采用排队.加速失败判定时间。

4:依赖调用结果分:成功,失败(抛出异常),超时,线程拒绝,短路。 请求失败(异常,拒绝,超时,短路)时执行fallback(降级)逻辑。

5:提供熔断器组件,可以自动运行或手动调用,停止当前依赖一段时间(10秒),熔断器默认错误率阈值为50%,超过将自动运行。

6:提供近实时依赖的统计和监控

Hystrix依赖的隔离架构,如下图:

服务隔离神器-Hystrix

三:如何使用Hystrix

1:使用maven引入Hystrix依赖

 

Html代码  

  1. <!-- 依赖版本 -->  

  2. <hystrix.version>1.3.16</hystrix.version>  

  3. <hystrix-metrics-event-stream.version>1.1.2</hystrix-metrics-event-stream.version>   

  4.    

  5. <dependency>  

  6.      <groupId>com.netflix.hystrix</groupId>  

  7.      <artifactId>hystrix-core</artifactId>  

  8.      <version>${hystrix.version}</version>  

  9.  </dependency>  

  10.      <dependency>  

  11.      <groupId>com.netflix.hystrix</groupId>  

  12.      <artifactId>hystrix-metrics-event-stream</artifactId>  

  13.      <version>${hystrix-metrics-event-stream.version}</version>  

  14.  </dependency>  


2:使用命令模式封装依赖逻辑

 

Java代码  

  1. public class HelloWorldCommand extends HystrixCommand<String> {  

  2.     private final String name;  

  3.     public HelloWorldCommand(String name) {  

  4.         //最少配置:指定命令组名(CommandGroup)  

  5.         super(HystrixCommandGroupKey.Factory.asKey("ExampleGroup"));  

  6.         this.name = name;  

  7.     }  

  8.     @Override  

  9.     protected String run() {  

  10.         // 依赖逻辑封装在run()方法中  

  11.         return "Hello " + name +" thread:" + Thread.currentThread().getName();  

  12.     }  

  13.     //调用实例  

  14.     public static void main(String[] args) throws Exception{  

  15.         //每个Command对象只能调用一次,不可以重复调用,  

  16.         //重复调用对应异常信息:This instance can only be executed once. Please instantiate a new instance.  

  17.         HelloWorldCommand helloWorldCommand = new HelloWorldCommand("Synchronous-hystrix");  

  18.         //使用execute()同步调用代码,效果等同于:helloWorldCommand.queue().get();   

  19.         String result = helloWorldCommand.execute();  

  20.         System.out.println("result=" + result);  

  21.    

  22.         helloWorldCommand = new HelloWorldCommand("Asynchronous-hystrix");  

  23.         //异步调用,可自由控制获取结果时机,  

  24.         Future<String> future = helloWorldCommand.queue();  

  25.         //get操作不能超过command定义的超时时间,默认:1秒  

  26.         result = future.get(100, TimeUnit.MILLISECONDS);  

  27.         System.out.println("result=" + result);  

  28.         System.out.println("mainThread=" + Thread.currentThread().getName());  

  29.     }  

  30.        

  31. }  

  32.     //运行结果: run()方法在不同的线程下执行  

  33.     // result=Hello Synchronous-hystrix thread:hystrix-HelloWorldGroup-1  

  34.     // result=Hello Asynchronous-hystrix thread:hystrix-HelloWorldGroup-2  

  35.     // mainThread=main  

 note:异步调用使用 command.queue()get(timeout, TimeUnit.MILLISECONDS);同步调用使用command.execute() 等同于 command.queue().get();

3:注册异步事件回调执行

 

Java代码  

  1. //注册观察者事件拦截  

  2. Observable<String> fs = new HelloWorldCommand("World").observe();  

  3. //注册结果回调事件  

  4. fs.subscribe(new Action1<String>() {  

  5.     @Override  

  6.     public void call(String result) {  

  7.          //执行结果处理,result 为HelloWorldCommand返回的结果  

  8.         //用户对结果做二次处理.  

  9.     }  

  10. });  

  11. //注册完整执行生命周期事件  

  12. fs.subscribe(new Observer<String>() {  

  13.             @Override  

  14.             public void onCompleted() {  

  15.                 // onNext/onError完成之后最后回调  

  16.                 System.out.println("execute onCompleted");  

  17.             }  

  18.             @Override  

  19.             public void onError(Throwable e) {  

  20.                 // 当产生异常时回调  

  21.                 System.out.println("onError " + e.getMessage());  

  22.                 e.printStackTrace();  

  23.             }  

  24.             @Override  

  25.             public void onNext(String v) {  

  26.                 // 获取结果后回调  

  27.                 System.out.println("onNext: " + v);  

  28.             }  

  29.         });  

  30. /* 运行结果 

  31. call execute result=Hello observe-hystrix thread:hystrix-HelloWorldGroup-3 

  32. onNext: Hello observe-hystrix thread:hystrix-HelloWorldGroup-3 

  33. execute onCompleted 

  34. */  

4:使用Fallback() 提供降级策略

服务隔离神器-Hystrix

 

Java代码  

  1. //重载HystrixCommand 的getFallback方法实现逻辑  

  2. public class HelloWorldCommand extends HystrixCommand<String> {  

  3.     private final String name;  

  4.     public HelloWorldCommand(String name) {  

  5.         super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("HelloWorldGroup"))  

  6.                 /* 配置依赖超时时间,500毫秒*/  

  7.                 .andCommandPropertiesDefaults(HystrixCommandProperties.Setter().withExecutionIsolationThreadTimeoutInMilliseconds(500)));  

  8.         this.name = name;  

  9.     }  

  10.     @Override  

  11.     protected String getFallback() {  

  12.         return "exeucute Falled";  

  13.     }  

  14.     @Override  

  15.     protected String run() throws Exception {  

  16.         //sleep 1 秒,调用会超时  

  17.         TimeUnit.MILLISECONDS.sleep(1000);  

  18.         return "Hello " + name +" thread:" + Thread.currentThread().getName();  

  19.     }  

  20.     public static void main(String[] args) throws Exception{  

  21.         HelloWorldCommand command = new HelloWorldCommand("test-Fallback");  

  22.         String result = command.execute();  

  23.     }  

  24. }  

  25. /* 运行结果:getFallback() 调用运行 

  26. getFallback executed 

  27. */  

 

NOTE: 除了HystrixBadRequestException异常之外,所有从run()方法抛出的异常都算作失败,并触发降级getFallback()和断路器逻辑。

          HystrixBadRequestException用在非法参数或非系统故障异常等不应触发回退逻辑的场景。

5:依赖命名:CommandKey

 

Java代码  

  1. public HelloWorldCommand(String name) {  

  2.         super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("ExampleGroup"))  

  3.                 /* HystrixCommandKey工厂定义依赖名称 */  

  4.                 .andCommandKey(HystrixCommandKey.Factory.asKey("HelloWorld")));  

  5.         this.name = name;  

  6.     }  

 NOTE: 每个CommandKey代表一个依赖抽象,相同的依赖要使用相同的CommandKey名称。依赖隔离的根本就是对相同CommandKey的依赖做隔离.

6:依赖分组:CommandGroup

命令分组用于对依赖操作分组,便于统计,汇总等.

Java代码  

  1. //使用HystrixCommandGroupKey工厂定义  

  2. public HelloWorldCommand(String name) {  

  3.     Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("HelloWorldGroup"))  

  4. }  

 NOTE: CommandGroup是每个命令最少配置的必选参数,在不指定ThreadPoolKey的情况下,字面值用于对不同依赖的线程池/信号区分.

7:线程池/信号:ThreadPoolKey

Java代码  

  1. public HelloWorldCommand(String name) {  

  2.         super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("ExampleGroup"))  

  3.                 .andCommandKey(HystrixCommandKey.Factory.asKey("HelloWorld"))  

  4.                 /* 使用HystrixThreadPoolKey工厂定义线程池名称*/  

  5.                 .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("HelloWorldPool")));  

  6.         this.name = name;  

  7.     }  

 NOTE: 当对同一业务依赖做隔离时使用CommandGroup做区分,但是对同一依赖的不同远程调用如(一个是redis 一个是http),可以使用HystrixThreadPoolKey做隔离区分.

           最然在业务上都是相同的组,但是需要在资源上做隔离时,可以使用HystrixThreadPoolKey区分.

9:信号量隔离:SEMAPHORE

  隔离本地代码或可快速返回远程调用(如memcached,redis)可以直接使用信号量隔离,降低线程隔离开销.

Java代码  

  1. public class HelloWorldCommand extends HystrixCommand<String> {  

  2.     private final String name;  

  3.     public HelloWorldCommand(String name) {  

  4.         super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("HelloWorldGroup"))  

  5.                 /* 配置信号量隔离方式,默认采用线程池隔离 */  

  6.                 .andCommandPropertiesDefaults(HystrixCommandProperties.Setter().withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.SEMAPHORE)));  

  7.         this.name = name;  

  8.     }  

  9.     @Override  

  10.     protected String run() throws Exception {  

  11.         return "HystrixThread:" + Thread.currentThread().getName();  

  12.     }  

  13.     public static void main(String[] args) throws Exception{  

  14.         HelloWorldCommand command = new HelloWorldCommand("semaphore");  

  15.         String result = command.execute();  

  16.         System.out.println(result);  

  17.         System.out.println("MainThread:" + Thread.currentThread().getName());  

  18.     }  

  19. }  

  20. /** 运行结果 

  21.  HystrixThread:main 

  22.  MainThread:main 

  23. */  

四:监控平台搭建Hystrix-dashboard

1:监控dashboard介绍

dashboard面板可以对依赖关键指标提供实时监控,如下图:

 服务隔离神器-Hystrix

2:实例暴露command统计数据

Hystrix使用Servlet对当前JVM下所有command调用情况作数据流输出

配置如下:

 

Xml代码  

  1. <servlet>  

  2.     <display-name>HystrixMetricsStreamServlet</display-name>  

  3.     <servlet-name>HystrixMetricsStreamServlet</servlet-name>  

  4.     <servlet-class>com.netflix.hystrix.contrib.metrics.eventstream.HystrixMetricsStreamServlet</servlet-class>  

  5. </servlet>  

  6. <servlet-mapping>  

  7.     <servlet-name>HystrixMetricsStreamServlet</servlet-name>  

  8.     <url-pattern>/hystrix.stream</url-pattern>  

  9. </servlet-mapping>  

  10. <!--  

  11.     对应URL格式 : http://hostname:port/application/hystrix.stream 

  12. -->  

 

2:Hystrix关键组件分析

 1):Hystrix流程结构解析

服务隔离神器-Hystrix

流程说明:

1:每次调用创建一个新的HystrixCommand,把依赖调用封装在run()方法中.

2:执行execute()/queue做同步或异步调用.

3:判断熔断器(circuit-breaker)是否打开,如果打开跳到步骤8,进行降级策略,如果关闭进入步骤.

4:判断线程池/队列/信号量是否跑满,如果跑满进入降级步骤8,否则继续后续步骤.

5:调用HystrixCommand的run方法.运行依赖逻辑

5a:依赖逻辑调用超时,进入步骤8.

6:判断逻辑是否调用成功

6a:返回成功调用结果

6b:调用出错,进入步骤8.

7:计算熔断器状态,所有的运行状态(成功, 失败, 拒绝,超时)上报给熔断器,用于统计从而判断熔断器状态.

8:getFallback()降级逻辑.

  以下四种情况将触发getFallback调用:

 (1):run()方法抛出非HystrixBadRequestException异常。

 (2):run()方法调用超时

 (3):熔断器开启拦截调用

 (4):线程池/队列/信号量是否跑满

8a:没有实现getFallback的Command将直接抛出异常

8b:fallback降级逻辑调用成功直接返回

8c:降级逻辑调用失败抛出异常

9:返回执行成功结果

2):熔断器:Circuit Breaker 

Circuit Breaker 流程架构和统计

服务隔离神器-Hystrix

每个熔断器默认维护10个bucket,每秒一个bucket,每个blucket记录成功,失败,超时,拒绝的状态,

默认错误超过50%且10秒内超过20个请求进行中断拦截. 

3)隔离(Isolation)分析

Hystrix隔离方式采用线程/信号的方式,通过隔离限制依赖的并发量和阻塞扩散.

(1):线程隔离

         把执行依赖代码的线程与请求线程(如:jetty线程)分离,请求线程可以自由控制离开的时间(异步过程)。

   通过线程池大小可以控制并发量,当线程池饱和时可以提前拒绝服务,防止依赖问题扩散。

   线上建议线程池不要设置过大,否则大量堵塞线程有可能会拖慢服务器。

(2):线程隔离的优缺点

线程隔离的优点:

[1]:使用线程可以完全隔离第三方代码,请求线程可以快速放回。

[2]:当一个失败的依赖再次变成可用时,线程池将清理,并立即恢复可用,而不是一个长时间的恢复。

[3]:可以完全模拟异步调用,方便异步编程。

线程隔离的缺点:

[1]:线程池的主要缺点是它增加了cpu,因为每个命令的执行涉及到排队(默认使用SynchronousQueue避免排队),调度和上下文切换。

[2]:对使用ThreadLocal等依赖线程状态的代码增加复杂性,需要手动传递和清理线程状态。

NOTE: Netflix公司内部认为线程隔离开销足够小,不会造成重大的成本或性能的影响。

Netflix 内部API 每天100亿的HystrixCommand依赖请求使用线程隔,每个应用大约40多个线程池,每个线程池大约5-20个线程。

(3):信号隔离

      信号隔离也可以用于限制并发访问,防止阻塞扩散, 与线程隔离最大不同在于执行依赖代码的线程依然是请求线程(该线程需要通过信号申请),

   如果客户端是可信的且可以快速返回,可以使用信号隔离替换线程隔离,降低开销.

   信号量的大小可以动态调整, 线程池大小不可以.

线程隔离与信号隔离区别如下图: