Hystrix 服务降级和熔断

最新推荐文章于 2024-06-11 13:41:41 发布
最新推荐文章于 2024-06-11 13:41:41 发布
阅读量1.9k 收藏 18
点赞数 4
分类专栏： 微服务框架 spring-boot spring cloud 文章标签： java 微服务 maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57752520/article/details/124087689
版权

Hystrix 服务降级和服务熔断

文章目录

说明：虽然该技术已近停更了，但是由于之后的一些服务降级技术和熔断机制都是借鉴了hystrix的设计理念，所以我们还是连接一下hystrix的设计思想和理念。 hystrix+eureka

1、问题的提出

服务雪崩

  • 多个微服务之间调用的时候，当A调用B，B调用C，一级一级的往下调用，这就是所谓的"扇出",当该调用的链路上如果某个微服务响应时间过长或者直接不可用了，那么所有的服务就会卡在这里，占用大量的系统资源，最终资源全部占用系统崩溃，这就是“雪崩效应”。
  • 对于高流量的应用来说，其占用了大量的系统资源，却又响应时间长，这也可能会导致其他的应用由于资源被占用了，本来流量少响应时间快，但因为大量资源被占用，所以可能导致延迟。
  • 为了解决该类的问题所以就有了服务降级和熔断。

2、Hystrix

hystrix是一个处理分布式系统的延迟和容错的开源库，能够保障再出问题的时候还可以维持高可用性，不会导致整体服务的失败、避免级联故障、以提高分布式系统的弹性

基本设计的思想：当发生服务调用故障时，向调用方返回一个符合预期的、可处理的备选响应（FallBack），而不是长期的等待或者抛出异常，这样就会保证了服务调用方法的线程不会被长期的、不必要的占用，从而避免了故障在分布式系统中的蔓延，乃至雪崩。

官网：Netflix/Hystrix: Hystrix is a latency and fault tolerance library designed to isolate points of access to remote systems, services and 3rd party libraries, stop cascading failure and enable resilience in complex distributed systems where failure is inevitable. (github.com)

作用：

  • 服务降级
  • 服务熔断
  • 服务限流
  • 实时监控等等

3、服务降级

什么是服务降级

  • 服务降级是当服务器压力剧增的情况下，根据当前业务情况及流量对一些服务和页面有策略的降级，以此释放服务器资源以保证核心任务的正常运行。
  • 通俗的讲就是当服务器繁忙时，不让服务继续在这里耗着，而是返回一个友好的提示【一个Fallback方法】，释放该线程的资源，减轻压力。

触发服务降级的情况

  • 程序运行时异常 【即程序错误异常】
  • 超时
  • 服务熔断也会触发服务降级
  • 线程池的最大线程数已满，无可再用线程
3.1 服务降级实操
  • 为了方便管理包创建一个父工程
  • pom.xml
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.6.5</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>2021.0.1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2021.0.1.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
  • 创建一个子工程

在这里插入图片描述

  • pom.xml
<dependencies>
    <!--hystrix-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        <version>2.2.10.RELEASE</version>
    </dependency>
    <!--eureka客户端-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
        <version>2.6.5</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <version>2.6.5</version>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>
  • yaml
server:
  port: 8003

spring:
  application:
    name: cloud-provide-payment

eureka:  #注册中心
  client:
    register-with-eureka: true
    service-url:
      defaultZone: http://localhost:7001/eureka
  instance:
    instance-id: payment8003
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 2
    lease-expiration-duration-in-seconds: 4
management:
  endpoints:
    web:
      exposure:
        include: "*"
  • 主启动类

加上@EnableCircuitBreaker 开启服务降级和熔断功能的注解

package com.qiumin;

import com.netflix.hystrix.contrib.metrics.eventstream.HystrixMetricsStreamServlet;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
@EnableEurekaClient   //开启eureka客户端
@EnableCircuitBreaker  //开启服务降级和熔断功能
public class payment8003Application {
    public static void main(String[] args) {
        SpringApplication.run(payment8003Application.class, args);
    }
}
  • service

@HystrixCommand @HystrixProperty 两个注解指定服务降级策略

package com.qiumin.service;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Service
public class paymentHystrixService {

    //=========服务降级================
    @HystrixCommand(fallbackMethod = "paymentInfo_TimeOutHandler",commandProperties = {
            @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value = "3000")
    })
    public String paymentInfo_ok(Integer id){
        return "线程池:     "+Thread.currentThread().getName()+" paymentInfo_ok,id:  "+id+"\t"+"哈哈";
    }

    @HystrixCommand(fallbackMethod = "paymentInfo_TimeOutHandler",commandProperties = {
            @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",value = "2000")
    })
    public String paymentInfo_TimeOut(Integer id){
        try {
            TimeUnit.MILLISECONDS.sleep(3000);  //3000>2000即响应时间大于最久等待时间  触发服务降级
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "线程池:     "+Thread.currentThread().getName()+" paymentInfo_TimeOut,id:  "+id+"\t"+"哈哈"+"耗时（毫秒）";
    }

    public String paymentInfo_TimeOutHandler(Integer id){
        return "线程池："+Thread.currentThread().getName()+"paymentInfo_TimeOutHandler,id:  "+id+"\t"+"服务降级！！！";
    }
    
//====================================================================================================
    
     //=========用于后面服务熔断测试================
    @HystrixCommand(fallbackMethod = "paymentCircuitBreakerFallback",commandProperties = {
            @HystrixProperty(name="circuitBreaker.enabled",value = "true"), //开启熔断器
            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold",value = "10"), //10次请求
            @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds",value = "10000"),//时间范围
            @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage",value = "60"),//请求次数中有60%错误，熔断器打开
    })
    public String paymentCircuitBreaker(@PathVariable("id") int id){
        if(id<0){
            throw new RuntimeException("****不能为负数****");
        }
        String uuid = UUID.randomUUID().toString();
        return Thread.currentThread().getName()+"\t"+"调用成功！！！ 流水号为:"+uuid;
    }

    public String paymentCircuitBreakerFallback(@PathVariable("id") int id){
        return "id 不能为负数，请稍后再试！！！"+id;
    }
}

核心：为可能会出现超时或者异常的方法编写一个服务降级的方法并调用该方法 fallbackMethod =“兜底的方法” 。

注意：兜底的方法必须与其服务降级的方法，格式上必须一模一样，例如：返回值类型、参数类型等等。

  • controller**
package com.qiumin.controller;

import com.qiumin.service.paymentHystrixService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Slf4j
public class paymentHystrixController {

    @Autowired
    paymentHystrixService paymentHystrixService;

    @GetMapping("/payment/hystrix/ok/{id}")
    public String paymentInfo_ok(@PathVariable("id") Integer id){
        return paymentHystrixService.paymentInfo_ok(id);
    }

    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id){
        return paymentHystrixService.paymentInfo_TimeOut(id);
    }
    
    
    //用于服务熔断测试
    @GetMapping("/payment/circuit/{id}")
    public String paymentCircuitBreaker(@PathVariable("id") int id){
        return paymentHystrixService.paymentCircuitBreaker(id);
    }

}
  • 启动注册中心和该服务，测试即可

由于如果给每个方法的写一个兜底的方法会导致代码量的激增，所以可以定义一个默认的兜底的方法，如果没有个别定制兜底方法就用默认的兜底方法。

3.2 服务降级之客户端

客户端可以有自己的服务降级和熔断策略，

由于我们使用openfeign客户端远程调用，为了解耦和代码量，我们可以在客户端的接口上做服务降级

具体实现：

  1. 单独创建一个类实现客户端接口，重写里面的方法，即用于服务降级的方法。
  2. 有服务降级就调用该类中的对应的方法。
  • 创建一个子工程客户端 【客户端调服务端】

在这里插入图片描述

  • pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud2022</artifactId>
        <groupId>com.qiu</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-consumer-hystrix-openfeign-order8888</artifactId>

    <properties>
        <maven.compiler.source>15</maven.compiler.source>
        <maven.compiler.target>15</maven.compiler.target>
    </properties>

    <dependencies>
        <!--hystrix-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            <version>2.2.10.RELEASE</version>
        </dependency>
        <!--开启openfeign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!--eureka客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!--web依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--图形化处理依赖，与后面的图形化监控可用-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
            <version>2.6.5</version>
        </dependency>
        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <version>2.6.5</version>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <!--lombok依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>
  • yaml
server:
  port: 8888

spring:
  application:
    name: cloud-consumer-order

eureka:
  client:
    register-with-eureka: true
    service-url:
      defaultZone: http://localhost:7001/eureka

feign:
  circuitbreaker:
    enabled: true    #开启服务降级
  • 客户端接口 【远程调用】**
package com.qiumin.client;

import com.qiumin.pojo.CommonResult;
import com.qiumin.pojo.Payment;
import com.qiumin.service.FallbackService;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@Component
@FeignClient(value = "CLOUD-PROVIDE-PAYMENT",fallback = FallbackService.class) //fallback指向我们写的服务                                                                                       降级需调用方法的类
public interface paymentClient {

    @RequestMapping("/payment/query/{id}")
    CommonResult<Payment> query(@PathVariable("id") int id);

    @RequestMapping("/payment/create")
    CommonResult<Payment> create(Payment payment);
}
  • 服务降级的方法类 【用于服务降级】
package com.qiumin.service;

import com.qiumin.client.paymentClient;
import com.qiumin.pojo.CommonResult;
import com.qiumin.pojo.Payment;
import org.springframework.stereotype.Component;

@Component
public class FallbackService implements paymentClient {
    @Override
    public CommonResult<Payment> query(int id) {
        return new CommonResult(444,"请求获取数据超时或错误，进行了服务降级操作！！！",null);
    }

    @Override
    public CommonResult<Payment> create(Payment payment) {
        return new CommonResult(444,"请求获取数据超时或错误，进行了服务降级操作！！！",null);
    }
}
  • controller
package com.qiumin.controller;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.qiumin.client.paymentClient;
import com.qiumin.pojo.CommonResult;
import com.qiumin.pojo.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;


@Controller
@Slf4j
public class OrderController {

    @Autowired
    paymentClient paymentClient;

    @RequestMapping("/consumer/payment/query/{id}")
    @ResponseBody

    public CommonResult<Payment> query(@PathVariable("id") int id){
        log.info("进入了该方法！！");
        return paymentClient.query(id);
    }

}
  • 测试即可
3.3 总结
  • 加上@EnableCircuitBreaker 开启服务降级和熔断功能的注解
  • @HystrixCommand @HystrixProperty 两个注解指定服务降级策略
  • 核心：为可能会出现超时或者异常的方法编写一个服务降级的方法并调用该方法 fallbackMethod =“兜底的方法”
  • 注意：兜底的方法必须与其服务降级的方法，格式上必须一模一样，例如：返回值类型、参数类型等等
  • 注意：使用客户端时的controller里如果没有兜底的方法就不能有错误，因为我们的服务降级是配置在了feignclient上面的，没有处理controller里的，需我们另外处理

4、服务熔断

什么是服务熔断，【类似保险丝】

  • 服务熔断的作用类似于我们家用的保险丝，当某服务出现不可用或响应超时的情况时，为了防止整个系统出现雪崩，暂时停止对该服务的调用。
  • 服务熔断也会触发服务降级，服务熔断会直接暂时拒绝请求，然后调用服务降级方法返回友好提示。

服务熔断机制：当出现故障时，在固定时间窗口内，接口调用超时比率达到一个阈值，会开启熔断。，熔断一旦开启，这时就会拒绝请求包括正确的请求，直接执行本地的默认方法，达到服务降级的效果，熔断不会一直开启，熔断后一段时间，会继续放一批请求，这是处于半熔断状态，当进去的请求得到成功执行时，这时会认为服务故障已经清除，熔断就会关闭，服务正常进行。

Hystrix设计了三种状态：

  • 熔断关闭状态（Closed）：服务正常进行，不受限制。
  • 熔断开启状态（Open）： 在固定时间内（Hystrix默认是10秒），接口调用出错比率达到一个阈值（Hystrix默认为50%），会进入熔断开启状态。这时就会拒绝所有服务，调用服务降级方法。
  • 半熔断状态（Half-Open）： 在进入熔断开启状态一段时间之后（Hystrix默认是5秒），熔断器会进入半熔断状态。该状态下会放一批请求，监控该批请求的正确率，如果成功率达到预约，就认为服务恢复正常，关闭熔断状态。

图示：

在这里插入图片描述

涉及到熔断器三个重要的参数： 快照时间窗、 请求总数阈值、错误百分比阈值

  1. **快照时间窗：**断路器确定是否打开需要统计的请求和错误数据，而统计的时间范围就是快照时间窗，默认为最近10秒。
  2. **请求总数阈值：**在快照时间窗内，必须满足请求总数阈值才可能发送熔断，默认20，意味着10秒内调用次数不足20次，即使所有请求的失败也不会触发服务熔断。
  3. **错误百分比阈值：**满足以上的前提下，请求错误率达到默认阈值50%就会触发服务熔断。
  • 测试见服务降级处的代码

qiumin

Qiumin~
关注
  • 4
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringCloud Hystrix 服务降级和熔断
fenggfa的博客
08-14 358
Hystrix 服务降级和熔断 代码编写和设置
SpringCloud微服务之Hystrix组件实现服务熔断的方法
08-25
SpringCloud微服务之Hystrix组件实现服务熔断的方法 微服务架构特点是多服务、多数据源、支撑系统应用，这样导致微服务...在实际应用中，可以使用Hystrix组件来实现服务熔断和降级，提高微服务系统的可靠性和弹性。
SpringCloud(三)：Hystrix服务降级与熔断
SuperDingpang的博客
11-03 931
简介Hystrix，并实现快速开始和较完整配置
微服务：Springboot集成Hystrix实现熔断、降级、隔离
勤于笔记，成于点滴。
07-04 3630
Springboot集成Hystrix实现熔断、降级、隔离较为简单，并且提供了hystrix-dashboard可视化仪表盘。Hystrix框架已经实现了熔断降级、隔离策略，我们集成后只需要根据自身情况进行配置选用即可。一般在微服务架构优先选择客户端熔断降级，当然也可在服务端进行注解配置。
Feign & Hystrix 超时配置
最新发布
chinusyan的专栏
06-11 455
Feign & Hystrix 超时配置
微服务之Hystrix降级熔断
Young_深情不及里子的博客
01-13 1028
Spring Cloud的服务降级熔断组件Hytrix的详细总结，包揽对Hytrix的详细介绍以及降级熔断的基本使用及效果展示。
SpringCloud-Hystrix服务降级与熔断简介与简单配置
白蝶的博客
06-17 1057
Hystrix包括服务降级与熔断 1）新建模块，导入依赖 2）修改appliction.yml配置文件，这里设置为单机Eureka，方便模拟测试 3）在启动类上添加注释@EnableEurekaClient，注册服务 4）创建两个service类，里面包含两个方法，其中一个进行线程等待 5）创建controller类，调用service方法 6）开启Jmeter，设置两万次请求并启动 7）我们手动访问http://localhost:8001/payment/hystrix/ok/1，此时会发现这个测试路
hystrix熔断降级Demo-1-4
03-23
通过学习和实践这个Demo，你将掌握如何利用Hystrix实现服务的熔断和降级，提升系统的容错能力，为构建高可用的分布式系统打下坚实基础。在实践中不断优化配置，平衡服务性能和容错性，是每个开发者都需要掌握的关键...
SpringCloud(Hystrix服务降级)
11-04
总的来说，Spring Cloud Hystrix 通过服务降级、断路器模式、线程隔离等策略，提高了微服务架构的容错性和稳定性。开发者可以通过配置断路器阈值、实现降级逻辑，以及利用监控工具，来精细化管理服务的健康状态，...
SpringCloud Hystrix服务熔断.docx
11-10
总之，SpringCloud Hystrix通过服务熔断和降级策略，提高了微服务架构的稳定性和容错性，是构建高可用系统的关键工具。通过理解其核心概念和使用方法，开发者可以更好地应对分布式系统中的复杂挑战，实现更加健壮的...
Hystrix 熔断、降级实例
01-10
HystrixCommand及配置实例，亲测可用，有参数配置说明
Hystrix断路器（已进入停更维护阶段）
weixin_45650737的博客
09-21 326
面临问题：复杂分布式体系结构中的应用程序有数十个依赖关系，咩咯
Hystrix熔断器
丝丝甜
08-24 591
Hystrix熔断器 一、Hystrix熔断器概述 Hystix 是 Netflix 开源的一个延迟和容错库，用于隔离访问远程服务、第三方库，防止出现级联失败（雪崩）。 雪崩：一个服务失败，导致整条链路的服务都失败的情形。 Hystix 主要功能： 隔离： 线程池隔离(线程池的线程数量是固定的，如果调用一个服务没有响应，那么那条线程也不会返回线程池，当程序调用这个有问题的服务次数多了，线程自然而然就不够了，也就造成了其他服务没有线程可以调用了。解决办法：线程池内的线程按照一定的规则分配固定数量调用服务
hystrix熔断与降级
小鲍侃java
11-15 1265
​ 总结来说就是如果下游服务挂了，而上游有多个服务去调用他，那么上游的服务就全部挂掉了，这样会造成雪崩效应，从而使服务大面积的失效。 这就需要在连接下游服务超时或者异常时会降级走我们定义的方法。或者在一段时间内失败的比例大于配置，那么熔断器会打开，即使正确调用还是会走降级方法。等过一段时间后会尝试重新调用，如果调用失败，继续熔断，如果成功则可以正常调用。 1.实现 1.修改Application类 修改application中开启Hystrix。 @EnableFeignClients #开启feign
Feign-Hystrix 熔断降级，一文看透本质
持之以恒
08-30 2163
最近这些年，微服务盛行。服务拆分越来越细、越来越多。为方便微服务之间的调用，各种 RPC 框架层出不穷，目的就是让开发者像调用本地方法一样调用微服务。 微服务之间交流的核心是网络请求，这个过程涉及到应用层和网络层： - 网络层：最常用的是 TCP / UDP 协议 - 应用层：本质上说，应用层协议是负责对数据编码、解码的约定，比如我们常见的 HTTP、Websocket 协议等。 一般情况下，我们想要实现网络通信，有两种选择： - 使用现成应用层协议：比如 http 等 - 基于网络层（TCP/UD
Hystrix的服务熔断和服务降级，从入门到精通！
qq_49559393的博客
09-12 482
6 Hystrix 服务熔断 复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可避免失败！ 什么是服务熔断 我们可以把熔断器想象为一个保险丝，在电路系统中，一般在所有的家电系统连接外部供电的线路中间都会加一个保险丝，当外部电压过高，达到保险丝的熔点时候，保险丝就会被熔断，从而可以切断家电系统与外部电路的联通，进而保障家电系统不会因为电压过高而损坏 熔断机制是对应雪崩效应的一种微服务链路保护机制。 在分布式系统架构中多个系统之间通常是通过远程RPC调用进行通信，也就是 A 系统调
Hystrix降级与熔断
vivibro的博客
05-21 1424
Hystrix 即熔断器，一种保护机制
Spring Cloud浅谈个人尝鲜------Hystrix 服务熔断，降级（四）
温故而知新
11-30 238
Spring Cloud浅谈个人尝鲜------Hystrix 服务熔断，降级（四） 1.服务熔断 服务熔断的作用类似于我们家用的保险丝，当某服务出现不可用或响应超时的情况时，为了防止整个系统出现雪崩，暂时停止对该服务的调用。 2.服务降级 服务降级是从整个系统的负荷情况出发和考虑的，对某些负荷会比较高的情况，为了预防某些功能（业务场景）出现负荷过载或者响应慢的情况，在其内部暂时舍弃对一些非核心的接口和数据的请求，而直接返回一个提前准备好的fallback（退路）错误处理信息。这样，虽然提供的是一个有损的服
Hystrix如何进行服务熔断和降级？它的原理是什么？
06-07
Hystrix通过断路器模式实现服务熔断和降级。 服务熔断：当一个依赖项的错误率或响应时间超过预设的阈值时，Hystrix会自动打开断路器，停止对该依赖项的调用，从而防止整个系统的崩溃。打开断路器后，Hystrix会定期尝试重新调用该依赖项，如果调用成功，则断路器会关闭，否则会继续保持打开状态。 服务降级：当一个依赖项出现错误或超时时，Hystrix会执行预设的回退逻辑，返回备用结果或执行备用逻辑。回退逻辑可以是硬编码的结果，也可以是调用其他依赖项或执行本地逻辑。 服务熔断和降级的原理是通过断路器模式实现的。断路器模式包括三种状态：关闭状态、打开状态和半开状态。初始状态为关闭状态，当一个依赖项的错误率或响应时间超过预设的阈值时，断路器会自动打开，进入打开状态。在打开状态下，所有对该依赖项的调用都将被拒绝，直到过了一段时间后，断路器会进入半开状态，尝试重新调用该依赖项。如果调用成功，则断路器会关闭，否则会重新打开，保持打开状态。 服务熔断和降级可以提高系统的弹性和可靠性，防止故障的影响扩散到整个系统。Hystrix通过断路器模式自动控制依赖项的访问，保护系统免受依赖项的故障和延迟的影响，提高系统的容错性和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值