SpringCloud-Hystrix熔断器

最新推荐文章于 2024-09-05 17:17:24 发布
最新推荐文章于 2024-09-05 17:17:24 发布
阅读量359 收藏
点赞数
分类专栏： 降级 熔断 线程池隔离信号量隔离 文章标签： spring cloud java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42292187/article/details/121791164
版权

Hystrixs是 Netflix 开源的一个延迟和容错库，用于隔离访问远程服务，防止出现级联失败（雪崩）。

主要功能：

  • 降级
  • 熔断
  • 隔离
  • 限流

雪崩效应：

微服务化产品线，每一个服务专心于自己的业务逻辑，并对外提供相应的接口，看上去似乎很明了，其实还有很多的东西需要考虑，比如：服务的自动扩充，熔断和限流等，随着业务的扩展，服务的数量也会随之增多，逻辑会更加复杂，一个服务的某个逻辑需要依赖多个其他服务才能完成。一但一个依赖不能提供服务很可能会产生雪崩效应，最后导致整个服务不可访问。
微服务之间进行rpc或者http调用时，我们一般都会设置调用超时，失败重试等机制来确保服务的成功执行，看上去很美，如果不考虑服务的熔断和限流，就是雪崩的源头。
假设我们有两个访问量比较大的服务A和B，这两个服务分别依赖C和D,C和D服务都依赖E服务

​

A和B不断的调用C,D处理客户请求和返回需要的数据。当E服务不能供服务的时候，C和D的超时和重试机制会被执行 

​

由于新的调用不断的产生，会导致C和D对E服务的调用大量的积压，产生大量的调用等待和重试调用，慢慢会耗尽C和D的资源比如内存或CPU，然后也down掉。 

​

A和B服务会重复C和D的操作，资源耗尽，然后down掉，最终整个服务都不可访问。 

1.降级 

类似于try catch,在出现异常或者超时或者服务不可用时返回一些默认处理方案

 降级方案可在服务提供方也可在服务调用方

环境搭建：

注册中心这里选用eureka

euerka-server 

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.0.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.zhangyong</groupId>
	<artifactId>eureka-server</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>eureka-server</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Greenwich.RELEASE</spring-cloud.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

 application.properties

spring.application.name=eureka-server #应用名称
eureka.client.fetch-registry=false #是否从注册中心拉取其他服务注册信息
eureka.client.register-with-eureka=false #是否将自己注册到注册中心

启动类

package com.zhangyong.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

	public static void main(String[] args) {
		SpringApplication.run(EurekaServerApplication.class, args);
	}

}

 eureka客户端

consumer（服务调用方）

pom.xml（consumer依赖）

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.0.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.zhangyong</groupId>
	<artifactId>comsumer</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>comsumer</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Greenwich.RELEASE</spring-cloud.version>
	</properties>
	<dependencies>
		<!--spring boot web-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

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

		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-openfeign</artifactId>
			<version>2.1.1.RELEASE</version>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

application.properties(三个服务端口分别为81、82、83)

eureka.client.service-url.defaultZone=http://localhost:8080/eureka
server.port=81
spring.application.name=consumer
feign.hystrix.enabled=true #给feign远程调用开启hytrix支持

 启动类

package com.zhangyong.comsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableFeignClients
@EnableEurekaClient
public class ComsumerApplication {

	public static void main(String[] args) {
		SpringApplication.run(ComsumerApplication.class, args);
	}

}

订单远程调用

package com.zhangyong.comsumer.api;

import com.zhangyong.comsumer.fallback.OrderFallback;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;

@FeignClient(value = "xxxooo",fallback = OrderFallback.class)
public interface OrderClient {
    @RequestMapping("getOrderList")
    String getOrderList();
}

订单服务调用方降级

package com.zhangyong.comsumer.fallback;

import com.zhangyong.comsumer.api.OrderClient;
import org.springframework.stereotype.Component;

@Component
public class OrderFallback implements OrderClient {
    @Override
    public String getOrderList() {
        return "订单列表降级方案";
    }
}

商品远程调用 

package com.zhangyong.comsumer.api;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@FeignClient("provider")
public interface ProductClient {
    @RequestMapping("getProductList/{id}")
    String getProductList(@PathVariable("id") String id);
}

controller

package com.zhangyong.comsumer.controller;

import com.zhangyong.comsumer.api.OrderClient;
import com.zhangyong.comsumer.api.ProductClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ConsumerController {

    @Autowired
    private OrderClient orderClient;

    @Autowired
    private ProductClient productClient;

    @RequestMapping("getOrderList")
    public String getOrderList() {
        return orderClient.getOrderList();
    }
    @RequestMapping("getProductList/{id}")
    public String getProductList(@PathVariable("id") String id) {
        return productClient.getProductList(id);
    }
}

 provider（服务提供方）

 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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.0.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.zhangyong</groupId>
	<artifactId>provicer</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>provicer</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Greenwich.RELEASE</spring-cloud.version>
	</properties>
	<dependencies>
		<!--spring boot web-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

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

		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

application.properties

eureka.client.service-url.defaultZone=http://localhost:8080/eureka
server.port=82
spring.application.name=provider

 启动类

@SpringBootApplication
@EnableEurekaClient
@EnableCircuitBreaker
public class ProvicerApplication {

	public static void main(String[] args) {
		SpringApplication.run(ProvicerApplication.class, args);
	}

}

controller

package com.zhangyong.provicer.controller;

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

@RestController
public class OrderController {
    @RequestMapping("getOrderList")
    public String getOrderList() {
        return "订单列表";
    }
}
package com.zhangyong.provicer.controller;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductController {
    @RequestMapping("getProductList/{id}")
    @HystrixCommand(fallbackMethod = "getProductList_fallback")
    public String getProductList(@PathVariable("id") String id){
        if ("0".equals(id)) {
            int i = 1 / 0;
        }
        return "商品列表";
    }

    public String getProductList_fallback(@PathVariable("id") String id){

        return "商品列表降级方案";
    }

}

 这里提醒一下，为了方便，我把order降级写在了服务调用方，product降级写在了服务提供方（配置了id传0会触发异常）

 看效果：

OrderClient.java中远程调用的服务名“xxxooo”是不存在的，这时候他会降级的（服务调用方降级）

ProductClient.java中 远程调用输入id为0是会降级的（服务提供方降级） 

 

2.熔断

Hystrix熔断机制，用于微服务之间的调用，当失败情况到达预定阈值（默认5秒失败20次），会打开断路器，断路器打开时，所有请求不管成功或者失败都会执行fallback降级方案，直到服务恢复正常为止

 如图所示：当断路器打开时，每过5秒钟会呈现一个半开状态，如果失败断路器继续打开，等待下一个5秒钟的半开状态，如果是调用成功，断路器就会关闭（不需要任何操作，hystrix默认实现）

接着上面的product的测试，当我们5秒超过20次id为0的操作（降级20次），他会拒绝所有请求。

可以看到一开始id为1是可以正常获取商品列表的

当5秒连续超过20次id为0的调用，再以一次id为1调用，可以看到不管是不是正常请求同样是返回降级，这就是触发了断路器

 

 熔断的触发条件也可以根据自己的需求进行配置

package com.zhangyong.provicer.controller;

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

@RestController
public class ProductController {
    @RequestMapping("getProductList/{id}")
    @HystrixCommand(fallbackMethod = "getProductList_fallback",commandProperties = {
            @HystrixProperty(name="circuitBreaker.sleepWindowInMilliseconds",value = "5000"),//监控时间
            @HystrixProperty(name="circuitBreaker.requestVolumeThreshold",value = "20"),//失败次数
            @HystrixProperty(name="circuitBreaker.errorThresholdPercentage",value = "50")//失败率
    })
    public String getProductList(@PathVariable("id") String id){
        if ("0".equals(id)) {
            int i = 1 / 0;
        }
        return "商品列表";
    }

    public String getProductList_fallback(@PathVariable("id") String id){

        return "商品列表降级方案";
    }

}

3.隔离、限流（隔离的同时达到了限流的效果）

说隔离之前要先知道，当我们要先知道，在不使用隔离之前，我们的所有请求都是从一个线程池（springboot默认集成tomcat）中获取的(如图所示)

 

 这样就会有个问题，当服务C不可用时，并且消耗了所有线程不归还，这样就会直接影响服务A，同时也导致B、C服务也没有可用的线程，也就时上面说的服务雪崩效应

 3-1.线程池隔离

顾名思义，线程池隔离就是将多个服务单独用线程池隔离开来，每个服务分配一部分的线程数量

这样的好处就是就是即使C服务出现问题，也不至于影响其他服务 ，还有一点就是，线程池隔离是异步操作的，服务A可以主动超时，并且归还线程

 

 3-2.信号量隔离 

信号量隔离与线程池隔离区别，信号量隔离和tomcat用的是同一组线程池里的线程，就好比计数器，给指定服务分配一定的信号量，拿到对应服务信号量才能调用，没拿到信号量配置了队列的，就在队列等待，没配置的直接fallback降级,当请求返回时才会归还信号量，并且是同步的，不能主动超时，也就是说当请求返回时才能判断该请求是否超时

下面看代码实现

增加一个provider2服务

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.0.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.zhangyong</groupId>
	<artifactId>provider2</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>provider2</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Greenwich.RELEASE</spring-cloud.version>
	</properties>
	<dependencies>
		<!--spring boot web-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

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

		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

eureka.client.service-url.defaultZone=http://localhost:8080/eureka
server.port=81
spring.application.name=consumer
#是否开启feign对hystrix支持
feign.hystrix.enabled=false
#最大并发数
server.tomcat.max-threads=10
#接受和处理的最大连接数
server.tomcat.max-connections=10
#初始化时创建的线程数
server.tomcat.min-SpareThreads=10
#可以放到处理队列中的请求数
server.tomcat.acceptCount=10
#远程连接超时时间
ribbon.ConnectTimeout=1000
#远程访问超时时间
ribbon.ReadTimeout=5000
//线程池隔离
 @HystrixCommand(groupKey = "user-pool",//服务名称
            commandKey = "getUserList",//接口名称，默认使用方法名
            threadPoolKey = "user-pool",//线程池名称
            commandProperties = {
                    @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "5000")
            },
            threadPoolProperties = {
                    @HystrixProperty(name = "coreSize", value = "6"),//线程池大小
                    @HystrixProperty(name = "maxQueueSize", value = "10"),//队列等待阈值（默认-1）
                    @HystrixProperty(name = "keepAliveTimeMinutes", value = "2"),//线程存活时间（默认 1min）
                    @HystrixProperty(name = "queueSizeRejectionThreshold", value = "10")//超出队列等待阈值执行拒绝策略
            },
            fallbackMethod = "aaa")
//信号量隔离
@HystrixCommand(commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "5000"),
            @HystrixProperty(name = HystrixPropertiesManager.EXECUTION_ISOLATION_STRATEGY, value = "SEMAPHORE"),
            @HystrixProperty(name = HystrixPropertiesManager.EXECUTION_ISOLATION_SEMAPHORE_MAX_CONCURRENT_REQUESTS, value = "4")
    },fallbackMethod = "bbb")

application.properties

eureka.client.service-url.defaultZone=http://localhost:8080/eureka
server.port=83
spring.application.name=provider2

启动类

package com.zhangyong.provider2;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
@EnableCircuitBreaker
public class Provider2Application {

	public static void main(String[] args) {
		SpringApplication.run(Provider2Application.class, args);
	}

}

controller

package com.zhangyong.provider2.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @RequestMapping(value = "getUserList",method = RequestMethod.GET)
    public String getUserList() {
        return "用户列表";
    }

    @RequestMapping(value = "getUserInfo",method = RequestMethod.GET)
    public String getUserInfo() {
        return "用户详情";
    }
}

 consumer服务需要改造一下

给consumer加入hystrix依赖

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

给consumer配置文件更新一下

这里为了测试方便，1.给初始线程限定为10，2.关闭feign对hystrix的支持(开启会导致hystrix超时失效) 3.feign底层的ribbon也有超时机制，需要修改ribbon的超时时间

eureka.client.service-url.defaultZone=http://localhost:8080/eureka
server.port=81
spring.application.name=consumer
#是否开启feign对hystrix支持
feign.hystrix.enabled=false
#最大并发数
server.tomcat.max-threads=10
#接受和处理的最大连接数
server.tomcat.max-connections=10
#初始化时创建的线程数
server.tomcat.min-SpareThreads=10
#可以放到处理队列中的请求数
server.tomcat.acceptCount=10
#远程连接超时时间
ribbon.ConnectTimeout=1000
#远程访问超时时间
ribbon.ReadTimeout=5000

consumer 使用hystrix启动类不要忘了加注解

package com.zhangyong.comsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableFeignClients
@EnableEurekaClient
@EnableCircuitBreaker
public class ComsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ComsumerApplication.class, args);
    }

}

给consumer 的 controller 加两个接口 和一个降级方法

package com.zhangyong.comsumer.controller;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import com.netflix.hystrix.contrib.javanica.conf.HystrixPropertiesManager;
import com.zhangyong.comsumer.api.OrderClient;
import com.zhangyong.comsumer.api.ProductClient;
import com.zhangyong.comsumer.api.UserClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ConsumerController {

    @Autowired
    private OrderClient orderClient;

    @Autowired
    private ProductClient productClient;

    @Autowired
    private UserClient userClient;

    @RequestMapping("getOrderList")
    public String getOrderList() {
        return orderClient.getOrderList();
    }

    @RequestMapping("getProductList/{id}")
    public String getProductList(@PathVariable("id") String id) {
        System.out.println(Thread.currentThread().getName());
        return productClient.getProductList(id);
    }
    @HystrixCommand(groupKey = "user-pool",//服务名称
            commandKey = "getUserList",//接口名称，默认使用方法名
            threadPoolKey = "user-pool",//线程池名称
            commandProperties = {
                    @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "5000")
            },
            threadPoolProperties = {
                    @HystrixProperty(name = "coreSize", value = "6"),//线程池大小
                    @HystrixProperty(name = "maxQueueSize", value = "10"),//队列等待阈值（默认-1）
                    @HystrixProperty(name = "keepAliveTimeMinutes", value = "2"),//线程存活时间（默认 1min）
                    @HystrixProperty(name = "queueSizeRejectionThreshold", value = "10")//超出队列等待阈值执行拒绝策略
            },
            fallbackMethod = "aaa")
    @RequestMapping("getUserList")
    public String getUserList() {
        System.out.println(Thread.currentThread().getName());
        return userClient.getUserList();
    }

    //信号量隔离
    @HystrixCommand(commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "5000"),//超时时间 5秒
            @HystrixProperty(name = HystrixPropertiesManager.EXECUTION_ISOLATION_STRATEGY, value = "SEMAPHORE"),//信号量隔离
            @HystrixProperty(name = HystrixPropertiesManager.EXECUTION_ISOLATION_SEMAPHORE_MAX_CONCURRENT_REQUESTS, value = "4")//分配的信号量数
    },fallbackMethod = "aaa")
    @RequestMapping("getUserInfo")
    public String getUserInfo() {
        System.out.println(Thread.currentThread().getName());
        return userClient.getUserInfo();
    }
    public String aaa() {
        System.out.println("降级了");
        return "aaa";
    }
}

 给consumer 加个 Userclient.java 用于远程调用 provider2服务

package com.zhangyong.comsumer.api;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@FeignClient("provider2")
public interface UserClient {
    @RequestMapping(value = "getUserList", method = RequestMethod.GET)
    String getUserList();

    @RequestMapping(value = "getUserInfo", method = RequestMethod.GET)
    String getUserInfo();
}

下面看线程池隔离效果：

getUserList是配置了线程池隔离的

 可以看到他们来自不同的线程池，这说明他们隔离开了，其实当加了@HystrixCommand注解后默认也会线程池隔离

信号量隔离效果：

需要借助一下jMeter测试工具 

线程组配置的是每秒5次请求循环1次

 http请求调用的是getUserInfo接口

 我配置的信号量是4个而我一次给了5个请求，所以有一个是降级的是正确的

线程池隔离与信号量隔离区别 

 线程池隔离

信号量隔离

 使用场景

 

帅帅勇
关注
专栏目录
SpringCloud之Hystrix
weixin_42408447的博客
05-04 503
1.服务熔断 服务熔断的作用类似于我们家用的保险丝，当某服务出现不可用或响应超时的情况时，为了防止整个系统出现雪崩，暂时停止对该服务的调用。 熔断机制是应对雪崩效应的一种微服务链路保护机制。我们在各种场景下都会接触到熔断这两个字。高压电路中，如果某个地方的电压过高，熔断器就会熔断，对电路进行保护。股票交易中，如果股票指数过高，也会采用熔断机制，暂停股票的交易。同样，在微服务架构中，熔断机制也是起着类似的作用。当扇出链路的某个微服务不可用或者响应时间太长时，会进行服务的降级，进而熔断该节点微服务的调用，快速返
Spring Cloud Hystrix
Lyzxii
06-14 1053
服务容错保护：Spring Cloud Hystrix 在微服务的架构中，存在着很多的服务单元，若一个单元出现故障，就很容易因依赖关系而引发故障蔓延，最终导致整个系统瘫痪，这样的架构相较传统的架构更加不稳定，为了解决这样的问题，产生了断路器等一系列的保护机制 针对上述问题,Spring Cloud Hystrix实现了断路器、线程隔离等一系列服务保护功能，该框架的目标在于通过控制那些远程系统、...
SpringCloud之CircuitBreaker
最新发布
qq_36813853的博客
09-05 781
Circuit Breaker只是一套规范和接口，落地实现者是Resilience4J。1、当满足一定的峰值和失败率达到一定条件后，断路器将会进入OPEN状态(保险丝跳闸)，服务熔断。2、当OPEN的时候，所有请求都不会调用主业务逻辑方法，而是直接走fallbackmetnod兜底背锅方法，服务降级。3、一段时间之后，这个时候断路器会从OPEN进入到HALF_OPEN半开状态，会放几个请求过去探探链路是否通？如成功，断路器会关闭CLOSE(类似保险丝闭合，恢复可用)；如失败，继续开启。重复上述。
SpringCloud10-Hystrix熔断器及服务熔断
06-01
本文将深入探讨Spring Cloud中的Hystrix熔断器以及服务熔断机制。 首先，理解什么是熔断器模式至关重要。熔断器模式源自电路设计，当电流超过一定阈值时，电路会自动断开以保护系统不受损害。在软件系统中，Hystrix...
spring-cloud-netflix-hystrix应用
02-19
7. **配置管理**：Hystrix的配置可通过Spring Cloud Config进行集中管理，方便在运行时动态调整熔断器的阈值、超时时间等参数，适应不断变化的业务需求。 在实践中，Spring Cloud Netflix Hystrix的使用通常包含...
SpringCloud10-Hystrix熔断器学习代码及指定默认的全局兜底方法
06-01
这个标题"SpringCloud10-Hystrix熔断器学习代码及指定默认的全局兜底方法"揭示了我们要讨论的主题——如何使用Hystrix进行熔断操作，并配置全局的 fallback 方法来处理服务调用失败的情况。 Hystrix的工作原理基于...
SpringCloud-Hystrix原理
02-24
融断：当失败率达到阀值自动触发降级(如因网络故障/超时造成的失败率高)，熔断器触发的快速失败会进行快速恢复。缓存：返回结果缓存，后续请求可以直接走缓存。请求合并：可以实现将一段时间内的请求（一般是对同一
SpringCloud-hystrix 熔断器
m0_46549085的博客
03-26 100
雪崩效应 在微服务中可能因为某一个微服务无法正常的提供的服务，导致整个系统无法提供服务，因为一台服务器的宕机导致整个系统的宕机，这种情况就叫做雪崩。 避免雪崩重要手段不是说避免服务器宕机，因为服务器宕机的可能太多了，比如断电、雷劈、硬件损坏、程序写得不好等等… hystrix 熔断器 豪猪 保护整个系统不会因为一个服务器的宕机而雪崩 作用有点类似于家里面保险丝（空开） 工作原理 主要涉及到熔断器的...
springcloud之hystrix
weixin_40482816的博客
07-29 220
1.什么是hystrix？ hystrix是Netlifx开源的一款容错框架，防雪崩利器，具备服务降级，服务熔断，依赖隔离，监控(Hystrix Dashboard)等功能. 2、hystrix能做什么？ Hystrix 负责监控服务之间的调用情况，连续多次失败的情况进行熔断保护。保护的方法就是使用Fallback，当调用的服务出现故障时，就可以使用Fallback 方法的返回值；Hystrix 间隔时间会再次检查故障的服务，如果故障服务恢复，将继续使用服务。 通过hystrix...
SpringCloud之hystrix
roykingw的专栏
07-02 754
本文目录一、关于hystrix二、hystrix的相关依赖三、hystrix主要功能1、以Command封装处理逻辑。封装、回调、容错3、 请求缓存4、信号量隔离 与 线程隔离5、线程合并6、hystrixDashboard三、关于服务安全 hystrix的功能比较杂乱， 代码就不全部贴了，只贴一部分。详细代码可以去博客上看，顺便给我点个star把。 https://gitee.com/tearw...
SpringCloud（Hystrix）
java is 因缺思厅
07-27 599
Hystrix 熔断器1. Hystrix 介绍1.1 是什么：1.2 Hystrix设计原则:2. 图解3. SpringCloud 集成Hystrix3.1 maven依赖3.2 添加注解 1. Hystrix 介绍 1.1 是什么： 在分布式环境中，许多服务依赖项中的一些必然会失败。Hystrix是一个库，通过添加延迟容忍和容错逻辑，帮助你控制这些分布式服务之间的交互。Hystrix通过隔离...
spring cloud Hystrix
燃烧的梦
06-06 349
springcloud的服务容错保护单元Hystrix基于Netflix开发 Hystrix 实现了断路器、线程隔离等一系列服务保护机制 该框架目标在于通过那些访问远程系统、服务、和第三方库的节点 ，从而对延迟和故障提供强大的容错能力。 Hystrix 具备服务降级、服务熔断、线程和信号隔离、请求缓存、请求合并以及服务监控等强大功能使用： 加入Hystrix的maven 启动applicat
springCloud Hystrix
u010548207的博客
08-19 153
Hystrix 介绍 在分布式系统中如何保证各个服务的健康机制，当某个服务出现故障时客户端页面不会一直等待，某个服务宕机不会影响整个的分布式服务，要解决这些问题就用到了高可用分布式系统的很多技术包括：资源隔离，限流与过载保护，熔断，优雅降级，容错，超时控制等。 服务雪崩效应 服务雪崩效应的产生是因为所有的服务堆积在同一个线程池中，所有的服务都是同一个线程池去处理，如果在高并发的情况下，所有的请求全...
Spring Cloud配置(四)熔断器
漫天雪_昆仑巅
08-16 1147
在Spring Cloud中使用了Hystrix 来实现断路器的功能。Hystrix是Netflix开源的微服务框架套件之一，该框架目标在于通过控制那些访问远程系统、服务和第三方库的节点，从而对延迟和故障提供更强大的容错能力。Hystrix具备拥有回退机制和断路器功能的线程和信号隔离，请求缓存和请求打包，以及监控和配置等功能。 以下分别在ribbon以及feign中配置断路器Hystrix 一...
SpringCloud-Hystrix：资源隔离与降级策略解析
- 熔断器模式：当服务调用失败率达到预设阈值时，Hystrix会自动触发熔断，进入“熔断”状态，此时所有请求都将被快速拒绝，而不是尝试调用服务。一段时间后，熔断器会进入“半开”状态，允许少量请求尝试，如果这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值