8.Hystrix理论篇

原创 已于 2023-02-16 20:25:20 修改 · 166 阅读 · 0 ·
CC 4.0 BY-SA版权
未经博主同意，禁止转载。
文章标签：

#hystrix #java #开发语言

于 2023-01-11 00:33:21 首次发布

1.简介
(1).作用
Hystrix是SpringCloud集成的容错组件，主要用于避免级联故障，提高系统可用性。
Hystrix提供的功能主要包括，服务熔断、服务限流、服务降级和服务监控。

(2).服务熔断
当服务A调用的服务B不可用时，服务A为了保证自己业务不受影响，从而不再调用服务B，直接返回一个结果，直到服务B可用。

(3).服务限流
在高并发请求下，为了保护系统，可以对访问服务的请求进行数量上的限制。

(4).服务降级
当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务有策略地不处理或换种简单的方式处理，从而释放服务器资源以保证核心业务正常运作。

2.架构图
在这里插入图片描述
(1).工作流程

  1. 调用入口方法
  2. 调用toObservable()
  3. 判断是否有缓存
  4. 熔断是否开启
  5. 限流是否触发
  6. 业务执行有没有失败
  7. 业务执行有没有超时

(2).引入依赖

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

3.HystrixCommand
(1).CommandDemo
会以隔离的形式完成run方法调用，默认线程池隔离。

public class CommandDemo extends HystrixCommand<String> {
    private String name;

    public CommandDemo(String name) {
        super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("CommandDemo")));
        this.name = name;
    }

    @Override
    protected String run() {
        String result = "CommandDemo name:" + name;

        System.err.println(result + ",currentThread:" + Thread.currentThread().getName());

        return result;
    }
}

(2).execute()

public class CommandTest {
    @Test
    public void executeTest() {
        long beginTime = System.currentTimeMillis();

        CommandDemo commandDemo = new CommandDemo("execute");
        //同步执行Command
        String result = commandDemo.execute();

        long endTime = System.currentTimeMillis();
        System.out.println(result + ",cost time:" + (endTime - beginTime) + "ms");
    }
}

在这里插入图片描述

(3).queue()

public class CommandTest {
   	@Test
    public void queueTest() throws ExecutionException, InterruptedException {
        long beginTime = System.currentTimeMillis();

        CommandDemo commandDemo = new CommandDemo("queue");
        //异步执行Command
        Future<String> queue = commandDemo.queue();

        long endTime = System.currentTimeMillis();
        System.out.println("future end,cost time:" + (endTime - beginTime) + "ms");

        long endTime2 = System.currentTimeMillis();

        System.out.println(queue.get() + ",cost time:" + (endTime2 - beginTime) + "ms");
    }
}

在这里插入图片描述

(4).observe()

public class CommandTest {
	@Test
    public void observeTest() {
        long beginTime = System.currentTimeMillis();

        CommandDemo commandDemo = new CommandDemo("observe");
        Observable<String> observe = commandDemo.observe();
        //阻塞式调用
        String result = observe.toBlocking().single();

        long endTime = System.currentTimeMillis();
        System.out.println(result + "cost time:" + (endTime - beginTime) + "ms");
	}
}

在这里插入图片描述

public class CommandTest {
	@Test
    public void observeTest() {
        long beginTime = System.currentTimeMillis();

        CommandDemo commandDemo = new CommandDemo("observe");
        Observable<String> observe = commandDemo.observe();
        //阻塞式调用
        String result = observe.toBlocking().single();

        long endTime = System.currentTimeMillis();
        System.out.println(result + "cost time:" + (endTime - beginTime) + "ms");

        //非阻塞式调用
        observe.subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.err.println("observe,onCompleted");
            }

            @Override
            public void onError(Throwable throwable) {
                System.err.println("observe,onError-throwable:" + throwable);
            }

            @Override
            public void onNext(String result) {
                long endTime = System.currentTimeMillis();
                System.err.println(result + "cost time:" + (endTime - beginTime) + "ms");
            }
        });
    }
}

在这里插入图片描述

(5).observe()

public class CommandTest {
	    @Test
    public void toObserveTest() throws InterruptedException {
        long beginTime = System.currentTimeMillis();

        CommandDemo commandDemo1 = new CommandDemo("toObservable1");
        Observable<String> toObservable1 = commandDemo1.toObservable();
        //阻塞式调用
        String result = toObservable1.toBlocking().single();

        long endTime = System.currentTimeMillis();
        System.out.println(result + "cost time:" + (endTime - beginTime) + "ms");
    }
}

在这里插入图片描述

public class CommandTest {
	@Test
    public void toObserveTest() throws InterruptedException {
        long beginTime = System.currentTimeMillis();

        CommandDemo commandDemo1 = new CommandDemo("toObservable1");
        Observable<String> toObservable1 = commandDemo1.toObservable();
        //阻塞式调用
        String result = toObservable1.toBlocking().single();

        long endTime = System.currentTimeMillis();
        System.out.println(result + "cost time:" + (endTime - beginTime) + "ms");

        CommandDemo commandDemo2 = new CommandDemo("toObservable2");
        Observable<String> toObservable2 = commandDemo2.toObservable();
        //非阻塞式调用
        toObservable2.subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.err.println("toObservable,onCompleted");
            }

            @Override
            public void onError(Throwable throwable) {
                System.err.println("toObservable,onError - throwable=" + throwable);
            }

            @Override
            public void onNext(String result) {
                long endTime = System.currentTimeMillis();
                System.err.println(result + "cost time:" + (endTime - beginTime) + "ms");
            }
        });
        Thread.sleep(2000l);
    }
}

在这里插入图片描述

(6).四个方法的区别

  • execute:单次处理，同步执行
  • queue:单次处理，异步执行
  • observe:多次处理，Hot处理
    • 执行Command的run方法
    • 加载注册Subscriber对象
    • 将run方法结果注入到Subscriber对象的onNext方法
  • toObserve:多次处理，Cold处理，每次订阅都需要一个新的Command对象
    • 加载注册Subscriber对象
    • 执行Command的run方法
    • 将run方法结果注入到Subscriber对象的onNext方法

4.ObserveableCommand
(1).ObserveableCommandDemo
使用当前线程进行调用，默认信号量隔离，也可以通过设置使用不同线程执行。

public class ObservableCommandDemo extends HystrixObservableCommand<String> {

    private String name;

    public ObservableCommandDemo(String name) {
        super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("ObservableCommandDemo"))
                .andCommandKey(HystrixCommandKey.Factory.asKey("ObservableCommandDemo")));
        this.name = name;
    }

    @Override
    protected Observable<String> construct() {
        System.err.println("currentThread:" + Thread.currentThread().getName());

        return Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                //业务处理
                subscriber.onNext("action 1,name:" + name);
                subscriber.onNext("action 2,name:" + name);
                subscriber.onNext("action 3,name:" + name);

                //业务处理结束
                subscriber.onCompleted();
            }
        }).subscribeOn(Schedulers.io());
    }
}

(2).observe()

public class ObservableCommandTest {
    @Test
    public void observeTest() throws InterruptedException {
        long beginTime = System.currentTimeMillis();

        ObservableCommandDemo observableCommandDemo = new ObservableCommandDemo("ObservableCommandDemo-observe");
        Observable<String> observe = observableCommandDemo.observe();
        //非阻塞式调用
        observe.subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.err.println("ObservableCommandDemo-observe,onCompleted");
            }

            @Override
            public void onError(Throwable throwable) {
                System.err.println("ObservableCommandDemo-observe,onError-throwable=" + throwable);
            }

            @Override
            public void onNext(String result) {
                long endTime = System.currentTimeMillis();
                System.err.println(result + "cost time:" + (endTime - beginTime) + "ms");
            }
        });

        Thread.sleep(1000l);
    }
}

在这里插入图片描述

5.请求缓存
(1).简介

  • Hystrix支持将请求结果进行本地缓存
  • 请求缓存要求必须在同一个上下文
  • 通过实现getCacheKey方法来判断是否取出缓存
  • 可以通过RequestCacheEnabled开启请求缓存

(2).代码示例

public class CommandTest {
	@Test
    public void requestCache() {
        //开启请求上下文
        HystrixRequestContext requestContext = HystrixRequestContext.initializeContext();
        long beginTime = System.currentTimeMillis();

        CommandDemo c1 = new CommandDemo("c1");
        CommandDemo c2 = new CommandDemo("c2");
        CommandDemo c3 = new CommandDemo("c3");

        //第一次请求
        String r1 = c1.execute();
        System.out.println(r1 + "cost time:" + (System.currentTimeMillis() - beginTime) + "ms");

        //第二次请求
        String r2 = c2.execute();
        System.out.println(r2 + "cost time:" + (System.currentTimeMillis() - beginTime) + "ms");

        //第三次请求
        String r3 = c3.execute();
        System.out.println(r3 + "cost time:" + (System.currentTimeMillis() - beginTime) + "ms");

        //请求上下文关闭
        requestContext.close();
    }
}

在这里插入图片描述

6.熔断
(1).简介
熔断器是一个开关，用来控制流量是否执行业务逻辑。

(2).熔断器核心指标

指标含义
请求时间窗一个时间段
请求总数阈值核心时间窗内有多少请求总数
错误百分比阈值当达到请求总数阈值，同时错误达到一定比例，触发熔断开关

(3).熔断器状态

状态含义
开启所有请求都会进入fallback方法
半开启间歇性让请求触发run方法，成功则关闭熔断器
关闭正常处理业务请求

默认情况下，熔断器开启5秒后进入半开启状态，熔断器的计算是有耗时的，等待熔断健康检查。熔断器是可以强制手动开启或关闭。

聚焦Spring Cloud Hystrix原理与注意事项
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
02-14 167万+
本文介绍了Spring Cloud Hystrix框架在微服务架构中的应用，重点讲解了其通过熔断器、线程池隔离和降级策略等机制，提升系统的容错性和稳定性。Hystrix能够有效防止服务故障的连锁反应，确保系统的高可用性。通过对Hystrix的基本原理和实际应用的解析，本文为开发者提供了在分布式系统中实现错误处理和系统容错的思路。尽管新技术如Resilience4j逐步替代了Hystrix，但它依然是微服务容错设计的经典实践。
Spring Cloud 进阶--Rest微服务加入Hystrix断路器实现服务熔断与服务降级
Spring Boot-Common On With You
03-07 879
《 Hystrix断路器，实现服务的熔断与降级 》 前言 在上一篇文章中，主要完成了 《Rest微服务加入Feign负载均衡客户端组件 》，并且完成了 《Hystrix 基本理论概述 》的详细简介，本篇博客将带领读者完整在 Rest 微服务中集成 Hystrix 实现服务的熔断（服务端）与服务的降级（客户端），本...
熔断器Hystrix
08-22 169
什么是服务雪崩？ 单个服务发生故障，占用过多的系统资源，从而导致级联故障的情况称为服务雪崩。 什么是Hystrix？ 在分布式环境中，许多服务依赖项中的一些必然会失败。(服务挂了) Hystrix是一个库，通过添加延迟容忍和容错逻辑，控制这些分布式服务之间的交互。 Hystrix通过隔离服务之间的访问点、停止级联失败和提供回退选项来实现这一点，所有这些都可以提高系统的整体弹性。 容错...
分布式系统限流
define_us的专栏
12-27 417
hystrix可以参考下面的博文 https://blog.csdn.net/loushuiyifan/article/details/82702522 支付宝内部用的是guardian https://help.aliyun.com/document_detail/149848.html 资源隔离的思想参考上述的舱壁隔离模式，在hystrix中提供了两种资源隔离策略：线程池隔离、信号量隔离。 线程池隔离：线程池隔离会为每一个依赖创建一个线程池来处理来自该依赖的请求，不同的依赖线程池相互隔离，就算依赖
Spring cloud Hystrix 作用
qq690452074的专栏
03-09 609
服务降级 服务熔断 依赖隔离 监控（Hystrix Dashboard）
Spring Cloud Hystrix 作用
qq_33348135的博客
01-30 384
微服务架构的问题点： 1.网络原因、延迟 2.请求剧增、积压 3.线程资源无法释放等 防雪崩利器：如：A、B、C三个服务，A服务调用B服务，B服务调用C服务，这时C服务有问题，导致B服务重试，而A服务这时也得不到响应，也触发重试机制，导致A、B、C服务都不可用 1.服务降级(优先核心服务，非核心服务不可用或弱可用) 1.1 通过HystrixCommand注解指定 1.2 fallb...
Hystrix功能介绍
熙熙小学姐
10-05 2900
1、什么是Hystrix 在一个分布式系统中，必然会有部分系统的调用会失败。Hystrix是一个通过添加超时容错和失败容错逻辑来帮助你控制这些分布式系统的交互。Hystrix通过隔离服务之间的访问，阻止他们之间的级联故障以及提供后背选项来实现这些，所有新而这些都用来提高系统的整体弹性。 2、Hystrix用来做什么 Hystrix被设计用来解决一下几个方面 通过第三方（一般来源...
Springcloud-Alibaba 〖九〗Hystrix篇 服务降级,服务熔断,服务限流,图形化界面
kingtok的博客
03-28 3872
Springcloud-Alibaba 〖九〗Hystrix篇一. 分布式系统面临的问题1.1 服务雪崩二. Hystrix是什么? 一. 分布式系统面临的问题 复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可避免地损失的。 1.1 服务雪崩 多个微服务之间调用的时候，假设微服务A调用微服务B和微服务C,微服务B和微服务C又调用其它的微服务，这就是所谓的"扇出"。 如果...
Spring Cloud Feign【源码篇】Feign Hystrix Support
保持敏感！保持学习！
06-27 585
友情提示：如果你对 Feign 不是很了解，请先阅读 Feign 如何进行服务间调用 相关版本：Spring Boot 2.1.5.RELEASE 、Spring Cloud Greenwich.SR 回顾 在 Feign 如何进行服务间调用 一文中，提到了Feign 自动配置类 FeignAutoConfiguration。 在之前提到，Feign 对象进行实例化的时候会调用 Targe...
【细说漫谈】Hystrix之服务熔断
知识改变命运，ヾ(◍°∇°◍)ﾉﾞ【求关注】
05-21 399
本篇博客主要是向大家分享Hystrix服务熔断的相关理论及案例分析。
Linux操作系统中hystrix
最新发布
wang_san_sui_的博客
10-01 905
是一个做熔断的框架，当程序被高并发访问时可能会造成微服务的宕机，hystrix可以熔断微服务之间通信。防止后台服务发生雪崩。
hystrix的作用和小结
wzhzzzz的博客
10-14 4805
1. hystrix的作用 命令模式的请求：解耦了请求者和接受者，使得发送出去的命令可以排队、异步执行。 资源隔离：用ConcurrentHashMap绑定commandKey和线程池，当某个功能运行不稳定或有问题时，服务的其他部分不受影响。服务恢复比较快。 健康度统计和断路器：用ConcurrentHashMap绑定commandKey和HystrixCircuitBreaker类（断路器类）...
为什么大厂服务并发高却很稳定？分布式服务熔断降级限流利器至Hystrix
kxkxyzyz的博客
04-26 333
全文概览 [TOC] 为什么需要hystrix hystrix官网地址github Hystrix同样是netfix公司在分布式系统中的贡献。同样的也进入的不维护阶段。不维护不代表被淘汰。只能说明推陈出新技术在不断迭代。曾今的辉煌曾经的设计还是值得我们去学习的。 在分布式环境中，服务调度是特色也是头疼的一块。在服务治理章节我们介绍了服务治理的功能。前一课我们也介绍了ribbon、feign进行服务调用。现在自然的到了服务监控管理了。hystrix就是对服务进行隔离保护。以实现服务不会出
Hystrix的概念、作用、使用方法
科学的N次方
04-10 572
在上面的例子中，我们定义了一个名为 GetUserCommand 的 Hystrix 命令，用于调用用户信息服务获取用户信息。Hystrix 提供了一个弹性、可控的延迟和容错机制，通过对服务调用进行隔离、降级、断路器等处理，以确保系统在异常情况下依然能够提供基本的功能。假设有一个微服务架构中的用户信息服务，提供了获取用户信息的接口。Hystrix 是 Netflix 开源的一个用于分布式系统的延迟和容错库，其主要目的是提供容错能力，防止分布式系统中的雪崩效应。
黑马springcloud高级篇
08-23
对于黑马的Spring Cloud高级篇，我可以为你提供一些相关信息。黑马是一家知名的IT培训机构，他们提供了一门针对Spring Cloud的高级课程，旨在帮助开发者更深入地学习和应用Spring Cloud框架。 在这门课程中，你可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值