- 微信
- 微博
  
  分享文章到微博
- 复制链接
  
  复制链接到剪贴板

05、SpringCloud之Hystrix组件学习笔记

长路发表于 2022/11/28 20:07:27 2022/11/28

1.7k+ 0 0

【摘要】 Gitee仓库、Github仓库博客目录索引(持续更新)动力节点最新SpringCloud视频教程|最适合自学的springcloud+springcloudAlibabaPS本章节中部分图片是直接引用学习课程课件，如有侵权，请联系删除。熔断器，也叫断路器！（正常情况下断路器是关的只有出了问题才打开）用来保护微服务不雪崩的方法。思想和我们上面画的拦截器一样。Hystrix是Netflix公司开源的

@[toc]

前言

本节配套案例代码：Gitee仓库、Github仓库

所有博客文件目录索引：博客目录索引(持续更新)

PS：本章节中部分图片是直接引用学习课程课件，如有侵权，请联系删除。

一、服务雪崩

1.1、引出服务雪崩

分布式场景下：

在高并发场景下：由于服务之间会进行调用，一旦某个服务不可用，那么就会出现服务雪崩

一旦服务链路中出现了某个服务不可用，那么就会影响整个链路，从而出现不可预计的问题！

服务雪崩的本质：由于调用的服务方不可用，就会导致对应的线程没有及时回收。

解决关键：不管是调用成功还是失败，只要线程可以及时回收，就可以解决服务雪崩。

1.2、雪崩三阶段

1、服务不可用：硬件故障/程序Bug/缓存击穿/用户大量请求。

2、调用端重试加大流量：用户重试/代码逻辑重试。

3、服务调用者不可用：同步等待造成的资源耗尽。

1.3、如何解决服务雪崩

方案描述：

1、应用扩容：加机器或升级硬件。

2、流控：限流/关闭重试。

3、缓存预加载。

4、服务降级：服务接口拒绝服务/页面拒绝服务/延迟持久化/随机拒绝服务。

5、服务熔断。

方案一：修改调用的超时时长（不推荐）

思路：将服务间的调用超时时长改小，这样就可以让线程及时回收，保证服务可用

优点：非常简单，也可以有效的解决服务雪崩

缺点：不够灵活，有的服务需要更长的时间去处理（写库，整理数据）

方案二：设置拦截器（设置断路器）

思路：在调用远程服务前来设置一个拦截器来进行服务状态判断。

二、认识Hystrix

2.1、服务熔断概念及断路器

问题描述：当下游服务因某种原因突然变得不可用或响应过慢，上游服务为保证自己整体服务的可用性，不再继续调用目标服务，直接返回，快速释放资源，如果目标服务情况好转则恢复调用。

解决方案：断路器模式。

断路器原理：当远程服务被调用时，断路器将监视这个调用，如调用时间太长，断路器将会介入并中断调用。断路器将监视所有远程资源的调用，如对某个远程资源的调用失败次数足够多，那么断路器会出现并采取快速失败，阻止将来调用失败的远程资源

状态图：

解析：

断路器最开始处于closed状态，一旦检测到的错误到达一定数量，断路器便转为open状态(断路器打开)；
此时到达reset timeout时间会转移到half open状态；
尝试放行一部分请求到后端，一旦检测成功便回归到closed状态，即恢复服务

断路器实现方案：阿里的Sentinel、netflix的Hystric。

2.2、Spring Cloud Hystrix介绍

熔断器，也叫断路器！（正常情况下断路器是关的只有出了问题才打开）用来保护微服务不雪崩的方法。思想和我们上面画的拦截器一样。

Hystrix 是 Netflix 公司开源的一个项目，它提供了熔断器功能，能够阻止分布式系统中出现联动故障。Hystrix 是通过隔离服务的访问点阻止联动故障的，并提供了故障的解决方案，从而提高了整个分布式系统的弹性。

例如：微博弹性云扩容 Docker K8s。

三、快速入门Hystrix

3.1、搭建基础服务（服务提供方以及消费方）

项目版本：SpringBoot：2.3.12.RELEASE、SpringCloud：Hoxton.SR12

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.12.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
    <java.version>1.8</java.version>
    <spring-cloud.version>Hoxton.SR12</spring-cloud.version>
</properties>

注册中心使用之前案例中的Eureka，然后在04-hystrix中创建两个服务来进行demo展示。

1、创建借车服务：01-rent-car-service

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

①配置文件application.yml

server:
  port: 8081
spring:
  application:
    name: rent-car-service
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka
  instance:
    hostname: localhost
    instance-id: ${eureka.instance.hostname}:${spring.application.name}:${server.port}

②在启动器中添加开启EurekaClient：

@EnableEurekaClient

③添加控制器：controller/RentController.java

package com.changlu.rentcarservice.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Description:
 * @Author: changlu
 * @Date: 9:18 PM
 */
@RestController
public class RentCarController {

    @GetMapping("/rent")
    public String rent() {
        return "租车成功！";
    }

}

2、创建消费者服务：02-customer-service

①配置文件：application.yml：

server:
  port: 8082
spring:
  application:
    name: customer-service
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka
  instance:
    hostname: localhost
    instance-id: ${eureka.instance.hostname}:${spring.application.name}:${server.port}

②在启动器中添加服务发现注解以及扫描feign包注解

@EnableEurekaClient
@EnableFeignClients(basePackages = "com.changlu.customerservice.feign") //开启feign包扫描

③创建feign包，添加租车服务的接口方法

package com.changlu.customerservice.feign;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

/**
 * @Description:
 * @Author: changlu
 * @Date: 9:30 PM
 */
@FeignClient("rent-car-service")  //对应服务名
public interface CustomerRentFeign {

    @GetMapping("/rent")
    public String rent();

}

④创建控制器：controller/CustomerController.java

package com.changlu.customerservice.controller;

import com.changlu.customerservice.feign.CustomerRentFeign;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Description:
 * @Author: changlu
 * @Date: 9:28 PM
 */
@RestController
public class CustomerController {

    @Autowired
    private CustomerRentFeign customerRentFeign;//远程调用

    @GetMapping("/customerRent")
    public String customerRent() {
        System.out.println("来进行访问租车了！");
        //进行一个远程调用
        String rent = customerRentFeign.rent();
        return rent;
    }
}

至此两个服务目前已经搭建完成！

3.2、启动服务，引入服务调用失败问题

启动一个注册中心以及刚刚创建的两个服务：

访问一下（正常）：http://localhost:8082/customerRent

然后我们把RentCar服务关闭掉之后，再次访问：

若是服务不可用，那么就会出现服务调用失败的情况，对于在高并发情况下若是频繁出现这种情况则会导致服务雪崩，从而出现大问题！

那么如何解决呢？

3.3、解决方案：使用Hystrix熔断器

引入过程：

①引入Hystrix依赖：其实不引入也是可以的，因为feign依赖中就自带hystrix依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

②在配置中开启Hystrix熔断器：在Hoxton.SR12版本中默认是关闭的

feign:
  hystrix:
    enabled: true  # 熔断器开启

③编写对应feign的熔断器

package com.changlu.customerservice.feign.hystrix;

import com.changlu.customerservice.feign.CustomerRentFeign;
import org.springframework.stereotype.Component;

/**
 * @Description: 消费者-借车熔断器
 * @Author: changlu
 * @Date: 9:19 AM
 */
@Component
public class CustomerRentHystrix implements CustomerRentFeign {
    @Override
    public String rent() {
        return "租车成功！（熔断器）";
    }
}

④在对应的feign中添加相应的fallback属性来指定对应的熔断方法

@FeignClient(value = "rent-car-service", fallback = CustomerRentHystrix.class)

此时我们再来测试一下！

四、手写断路器

4.1、断路器设计

本质就是在当前远程调用发起前对其进行代理：

时间窗口滑动模型图：

断路器状态介绍以及不同的状态转变方案：三个状态closed、half open、open

关：服务正常调用 A---》B 
开：在一段时间内，调用失败次数达到阀值（5s 内失败 3 次）（5s 失败 30 次的）则断路器打开，直接 return 
半开：断路器打开后，过一段时间，让少许流量尝试调用 B 服务，如果成功则断路器关闭， 使服务正常调用，如果失败，则继续半开

注意点：

1、一个服务一个断路器实例。

2、其他手写时的相关问题。

断路器实例中的属性：①断路器当前的状态。②当前的错误次数。

三种状态如何切换？

默认刚开始是closed(也就是正常去进行远程调用状态)，一旦访问失败了一次，此时就会变为open状态，那么在open状态过程中会直接返回对应的断路器结果，在一定的时间窗口(指定秒数)到达之后【多线程添加一个定时器】，此时状态会进入到半开状态，那么就会放一些流量出来去尝试访问服务提供方，若是发现此时访问成功！那么状态依旧会修改为closed。

为什么要使用一个定时器来进行定期清除呢？一些大量并发场景下，需要使用一个定时器来进行对失败次数清零。

4.2、实现断路器功能

首先准备好在3.1中的调用服务新案例，然后我们基于此来实现一个断路器：

实现完成之后如下：

①状态枚举：

package com.changlu.myhystrix.hystrix.model;

/**
 * @Description:
 * @Author: changlu
 * @Date: 9:54 AM
 */
public enum  HystrixStatus {
    //定义三种状态：关闭、开启、半开
    CLOSE,
    OPEN,
    HALF_OPEN
}

②断路器注解：

package com.changlu.myhystrix.hystrix.anno;

import java.lang.annotation.*;

/**
 * @Description:
 * @Author: changlu
 * @Date: 9:59 AM
 */
@Target(ElementType.METHOD) //面向方法
@Retention(RetentionPolicy.RUNTIME)  //运行时
@Documented
@Inherited
public @interface MyHystrix {
}

③断路器切面：

package com.changlu.myhystrix.hystrix.aspect;

import com.changlu.myhystrix.hystrix.HystrixPlus;
import com.changlu.myhystrix.hystrix.model.HystrixStatus;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

/**
 * @Description: 熔断器切面
 * @Author: changlu
 * @Date: 10:00 AM
 */
@Component
@Aspect
public class HystrixAspect {

    //切面表达式
//    public static final String POINT_COT = "execution (* com.changlu.myhystrix.controller.CustomerController.customerRent(..))";

    //定义一个断路器Map
    private static Map<String, HystrixPlus> hystrixMap = new HashMap<>();

    static {
        hystrixMap.put("rent-car-service", new HystrixPlus());
    }

    //随机器工具
    public static ThreadLocal<Random> randomThreadLocal = ThreadLocal.withInitial(()->new Random());

    //根据注解来进行切面处理
    @Around(value = "@annotation(com.changlu.myhystrix.hystrix.anno.MyHystrix)")
    public Object hystrixAround(ProceedingJoinPoint joinPoint) {
        //结果集
        Object res = null;
        //根据当前的服务名来获取到对应的断路器
        HystrixPlus hystrix = hystrixMap.get("rent-car-service");
        HystrixStatus status = hystrix.getStatus();
        switch (status) {
            case CLOSE:
                try {
                    return joinPoint.proceed();
                } catch (Throwable throwable) {
                    throwable.printStackTrace();
                    //进行计数，并且响应结果
                    hystrix.addFailCount();
                    return "熔断器返回结果";
                }
            case OPEN://打开状态，表示不能调用
                return "熔断器返回结果";
            case HALF_OPEN:
                Random random = randomThreadLocal.get();
                int num = random.nextInt(5);//[0-4]
                //方便回收
                randomThreadLocal.remove();
                //放行部分流量
                if (num == 1) {
                    try {
                        res = joinPoint.proceed();
                        //调用成功,断路器关闭
                        hystrix.setStatus(HystrixStatus.CLOSE);
                        //进行唤醒清理程序
                        synchronized (hystrix.getLock()) {
                            hystrix.getLock().notifyAll();
                        }
                        return res;
                    } catch (Throwable throwable) {
                        throwable.printStackTrace();
                        return "熔断器返回结果";
                    }
                }
            default:
                return "熔断器返回结果";
        }
    }

}

④断路器实现：

package com.changlu.myhystrix.hystrix;

import com.changlu.myhystrix.hystrix.model.HystrixStatus;
import lombok.Data;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Description:
 * @Author: changlu
 * @Date: 10:04 AM
 */
@Data
public class HystrixPlus {

    //时间窗口
    private static final Integer WINDOW_TIME = 20;
    //失败次数
    private static final Integer MAX_FAIL_COUNT = 3;

    //定义一个状态
    private HystrixStatus status = HystrixStatus.CLOSE;

    //错误次数计数器
    private AtomicInteger currentFailCount = new AtomicInteger(0);

    //定义一个线程池
    private ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
            4,
            8,
30,
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(2000),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy()
    );

    //锁
    private Object lock = new Object();

    {
        //提交定期清零报错次数
        poolExecutor.execute(()->{
            while (true) {
                try {
                    TimeUnit.SECONDS.sleep(WINDOW_TIME);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //根据当前的状态来判断是否要进行清理
                if (this.status.equals(HystrixStatus.CLOSE)) {
                    this.currentFailCount.set(0);
                }else {
                    // 半开或者开 不需要去记录次数 这个线程可以不工作
                    // 学过生产者 消费者模型  wait notifyAll  condition singleAll await   它们只能随机唤醒某一个线程
                    // lock锁 源码  CLH 队列 放线程 A B C D E  park unpark  可以 唤醒指定的某一个线程
//                    LockSupport.park();
//                    LockSupport.unpark();
                    try {
                        //进行阻塞，防止大量占据cpu
                        this.lock.wait();
                        System.out.println("开始进行失败次数清零操作");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }

    //增加错误次数，若是错误此时达到瓶颈，那么就需要将当前状态转为open状态并提交定时任务来进行修改为half open状态，并且清零
    public void addFailCount() {
        int i = currentFailCount.incrementAndGet();
        if (i >= MAX_FAIL_COUNT) {
            //将当前熔断器状态设置开启状态
            this.status = HystrixStatus.OPEN;
            poolExecutor.execute(()->{
                try {
                    TimeUnit.SECONDS.sleep(WINDOW_TIME);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (this.status != HystrixStatus.CLOSE) {
                    //设置半开状态并且计数清零
                    this.status = HystrixStatus.HALF_OPEN;
                    this.currentFailCount.set(0);
                }
            });
        }
    }

}

4.3、断路器测试

初始情况：启动三个服务，分别是注册中心，服务提供者以及服务消费方（也就是我们自定义实现断路器）

访问下网址路径：http://localhost:8082/customerRent

关闭服务提供方：

再此尝试访问：可以看到我们实现的熔断器起了效果

最终我们重启服务提供方：

可以看到也能够进行访问！

五、Hystrix配置

详细配置：hystrix 配置

对于配置中的隔离方式策略介绍如下：隔离策略包含thread线程以及semphore信号量隔离

线程隔离（场景：访问量比较大）：

说明：按照 group（10 个线程）划分服务提供者，用户请求的线程 和做远程的线程不一样。
好处：当 B 服务调用失败了 或者请求 B 服务的量太大了 不会对 C 服务造成影响 用户访问比较大的情 况下使用比较好 异步的方式。
缺点：具有线程切换的开销，对机器性能影响。
应用场景 调用第三方服务 并发量大的情况下

SEMAPHORE 信号量隔离（场景：访问量比较小）：

说明：每次请进来 有一个原子计数器 做请求次数的++ 当请求完成以后 --。
好处：对 cpu 开销小。
缺点：并发请求不易太多 当请求过多 就会拒绝请求 做一个保护机制。
场景：使用内部调用 ，并发小的情况下。
源码入门 HystrixCommand AbstractCommand HystrixThreadPool

参考资料

[1]. hystrix 配置

[2]. Hystrix的原理及使用

【声明】本内容来自华为云开发者社区博主，不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息，否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com

点赞
收藏
关注作者

作者其他文章

抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认取消

开发者空间

了解空间

工作台

开发工具

实战案例

空间活动

空间论坛

开发平台

软件开发生产线 CodeArts

AI平台ModelArts

数据治理中心 DataArts Studio

数字内容生产线 MetaStudio

精选服务

云数据库 GaussDB

云数据库 RDS for MySQL

MapReduce服务 MRS

数据仓库服务 DWS

分布式缓存服务Redis版

分布式消息服务 DMS

华为云实时音视频 SparkRTC

媒体处理 MPC

主机迁移服务 SMS

对象存储迁移服务 OMS

云消息服务 KooMessage

云手机服务 KooPhone

企业搜索服务 KooSearch

云地图服务 KooMap

更多开放能力

开发工具

API生态

CodeArts API

API Explorer

Terraform Explorer

KooCLI

API 中心

SDK 中心

开发服务

Codelabs

DevStar

低代码平台Astro

CodeArts IDE

Huawei Cloud Toolkit

Classroom

开发资源

开源镜像站

开源资源

开发语言

开发实践

入门精选

分发资源

企业应用中心

企业通用专区

教育专区

华为应用专区

政务云专区

硬件云服务商城

医疗健康专区

跳蚤市场

华为云开发者日

直播专区

开发者精品活动

DTSE Tech Talk

加入HCDE

加入HCDG

加入HCSD

加入HCWD

鲁班会

沃土云创计划·企业

沃土云创计划·高校

沃土云创计划·个人

沃土云创计划·开源共创

博客

论坛

专题

开发者榜单

学习路径

在线课程

动手实验

考试认证

培训服务