熔断器（Hystrix，Resilience4j）

熔断器

核心原理

熔断器通过监控服务调用失败率，在达到阈值时自动切断请求，进入熔断状态（类似电路保险丝）。其核心流程为：
关闭状态（Closed）：正常处理请求，统计失败率。
打开状态（Open）：触发熔断，直接拒绝请求，调用降级逻辑。
半开状态（Half-Open）：允许少量请求尝试恢复，若成功则关闭熔断。

状态流转

关闭状态（Closed）
行为：熔断器关闭，所有请求正常通过。
触发条件：
初始默认状态。
从半开状态恢复成功后切换至此状态。
核心规则：
统计时间窗口内的请求失败率。
当失败率超过阈值（如 50%）时，熔断器跳转到打开状态。

# Resilience4j 配置（失败率 ≥ 50% 触发熔断）
resilience4j.circuitbreaker:
  instances:
    serviceA:
      failureRateThreshold: 50
      minimumNumberOfCalls: 5  # 最少需要5次调用才计算失败率
      slidingWindowSize: 10     # 统计最近10次调用

打开状态（Open）
行为：熔断器打开，所有请求被快速拒绝，直接触发降级逻辑。
触发条件：
关闭状态下失败率超过阈值。
核心规则：
熔断器保持打开状态一段时间（如 10秒）。
超时后自动进入半开状态。
半开状态（Half-Open）
行为：允许少量探测请求通过，若成功则恢复服务，否则重新熔断。
触发条件：
熔断器从打开状态等待指定时间后自动切换。
核心规则：
允许有限数量的请求（如 3次）试探性调用。
若成功率达标（如 80%），则关闭熔断器。
若失败率仍高，则重新进入打开状态。

# Resilience4j 半开状态配置
resilience4j.circuitbreaker:
  instances:
    serviceA:
      permittedNumberOfCallsInHalfOpenState: 3  # 允许3次探测请求
      failureRateThreshold: 20                  # 半开状态下失败率≥20%则重新熔断
      waitDurationInOpenState: 10s              # 打开状态持续10秒后进入半开

Hystrix使用

依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    <version>2.2.10.RELEASE</version> <!-- 对应 Spring Cloud Hoxton.SR12 -->
</dependency>

启用 Hystrix

@SpringBootApplication
@EnableHystrix          // 启用 Hystrix
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

全局默认配置

hystrix:
  command:
    default:
      execution:
        isolation:
          strategy: THREAD  # 隔离策略（THREAD 或 SEMAPHORE）
          thread:
            timeoutInMilliseconds: 2000  # 超时时间（默认1秒）
      circuitBreaker:
        enabled: true                   # 是否启用熔断
        requestVolumeThreshold: 5       # 触发熔断的最小请求数
        errorThresholdPercentage: 50    # 失败率阈值（%）
        sleepWindowInMilliseconds: 10000 # 熔断持续时间（ms）
  threadpool:
    default:
      coreSize: 10       # 线程池核心线程数
      maxQueueSize: 100  # 最大队列容量（-1表示禁用队列）
      queueSizeRejectionThreshold: 20  # 队列拒绝阈值

使用示例

基础熔断与降级

@Service
public class UserService {

    @HystrixCommand(
        fallbackMethod = "getUserFallback",
        commandProperties = {
            // 自定义熔断规则（覆盖全局配置）
            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "3"),
            @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "5000")
        }
    )
    public String getUser(String userId) {
        if ("error".equals(userId)) {
            throw new RuntimeException("模拟服务失败");
        }
        return "User:" + userId;
    }

    // 降级方法（参数必须与原方法一致）
    public String getUserFallback(String userId) {
        return "Fallback User:" + userId;
    }
}

异步调用

@HystrixCommand(fallbackMethod = "asyncFallback")
public Future<String> asyncGetUser(String userId) {
    return new AsyncResult<String>() {
        @Override
        public String invoke() {
            return "Async User:" + userId;
        }
    };
}

public String asyncFallback(String userId) {
    return "Async Fallback:" + userId;
}

忽略特定异常

@HystrixCommand(
    fallbackMethod = "validateFallback",
    ignoreExceptions = { IllegalArgumentException.class }  # 此异常不触发熔断
)
public String validate(String input) {
    if (input.isEmpty()) {
        throw new IllegalArgumentException("输入为空");
    }
    return "Valid:" + input;
}

Hystrix+Feign Client 实现熔断

启用 Hystrix 和 Feign

@SpringBootApplication
@EnableFeignClients    // 启用 Feign Client
@EnableHystrix          // 启用 Hystrix
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

定义 Feign 接口及降级类

// Feign Client 接口
@FeignClient(
    name = "user-service",
    url = "http://localhost:8081",
    fallback = UserServiceFallback.class  // 指定降级类
)
public interface UserServiceClient {
    @GetMapping("/users/{userId}")
    User getUser(@PathVariable String userId);
}

// 降级类实现 Feign 接口
@Component
public class UserServiceFallback implements UserServiceClient {
    @Override
    public User getUser(String userId) {
        return new User(userId, "Fallback User");
    }
}

配置熔断参数 (application.yml)

feign:
  hystrix:
    enabled: true  # 启用 Hystrix 支持（默认 true，可省略）

hystrix:
  command:
    default:
      circuitBreaker:
        requestVolumeThreshold: 5       # 触发熔断的最小请求数
        errorThresholdPercentage: 50    # 失败率阈值（%）
        sleepWindowInMilliseconds: 10000 # 熔断持续时间（ms）
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 3000  # 超时时间

禁用 Hystrix 对特定 Feign Client

@FeignClient(
    name = "order-service",
    url = "http://localhost:8082",
    configuration = FeignDisableHystrixConfig.class
)
public interface OrderServiceClient { ... }

// 自定义配置类
public class FeignDisableHystrixConfig {
    @Bean
    public Feign.Builder feignBuilder() {
        return Feign.builder();  // 不使用 Hystrix
    }
}

注意

Hystrix 熔断器在打开状态（Open）后，默认经过 5秒进入半开状态（Half-Open）
可以通过 circuitBreaker.sleepWindowInMilliseconds 参数调整等待时间。

@HystrixCommand(
    commandProperties = {
        @HystrixProperty(
            name = "circuitBreaker.sleepWindowInMilliseconds", 
            value = "10000" // 10秒后进入半开状态
        )
    }
)
public String callService() { ... }

Hystrix 的半开状态逻辑是固定不可配置的(Resilience4j可以进行配置)，其行为如下：
探测请求数量：仅允许 1次请求通过。
熔断关闭条件：
如果探测请求成功，熔断器关闭，恢复服务。
如果探测请求失败，熔断器重新打开，继续等待下一个 sleepWindowInMilliseconds 周期。

Resilience4j使用

依赖

<!-- Resilience4j 核心模块 -->
<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot2</artifactId>
    <version>1.7.1</version>
</dependency>
<!-- 支持注解方式（需 Spring AOP） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

使用示例

熔断器

配置

resilience4j:
  circuitbreaker:
    instances:
      userService:
        failureRateThreshold: 50      # 失败率阈值（%）
        minimumNumberOfCalls: 5      # 触发统计的最小请求数
        slidingWindowType: COUNT_BASED  # 滑动窗口类型
        slidingWindowSize: 10         # 窗口大小（次数）
        waitDurationInOpenState: 10s  # 熔断持续时间
        permittedNumberOfCallsInHalfOpenState: 3  # 半开状态允许的请求数
        ignoreExceptions:             # 忽略特定异常（不触发熔断）
          - com.example.BusinessException

代码

@Service
public class UserService {

    @CircuitBreaker(name = "userService", fallbackMethod = "getUserFallback")
    public User getUser(String userId) {
        if (userId == null) {
            throw new RuntimeException("Invalid User ID");
        }
        return new User(userId, "Active");
    }

    // 降级方法（参数需一致，可添加异常参数）
    public User getUserFallback(String userId, Exception ex) {
        return new User(userId, "Fallback");
    }
}

Resilience4j+Feign Client 实现熔断

配置

resilience4j:
  circuitbreaker:
    instances:
      userService:  # 熔断器实例名（需与 Feign Client 名称对应）
        failureRateThreshold: 50     # 失败率阈值（%）
        minimumNumberOfCalls: 5    # 触发统计的最小请求数
        slidingWindowType: COUNT_BASED  # 滑动窗口类型
        slidingWindowSize: 10       # 窗口大小（次数）
        waitDurationInOpenState: 10s  # 熔断持续时间
        permittedNumberOfCallsInHalfOpenState: 3  # 半开状态允许的请求数
        recordExceptions:          # 触发熔断的异常类型
          - java.io.IOException
          - java.util.concurrent.TimeoutException

代码

@FeignClient(
    name = "userService",  // 与熔断器实例名一致
    url = "http://localhost:8081",
    fallback = UserServiceFallback.class // 直接指定降级类
)
public interface UserServiceClient {

    @GetMapping("/users/{userId}")
    User getUser(@PathVariable String userId);
}

熔断降级类

@Component
public class UserServiceFallback implements UserServiceClient {

    @Override
    public User getUser(String userId) {
        // 熔断降级逻辑
        return new User(userId, "Fallback User");
    }
}

在降级方法中捕获异常

@Component
public class UserServiceFallback implements UserServiceClient {

    @Override
    public User getUser(String userId, Throwable ex) {  // 添加 Throwable 参数
        log.error("Fallback triggered by: {}", ex.getMessage());
        return new User(userId, "Fallback User");
    }
}

重试（Retry）

配置

resilience4j:
  retry:
    instances:
      paymentService:
        maxAttempts: 3              # 最大重试次数
        waitDuration: 500ms         # 重试间隔
        retryExceptions:            # 触发重试的异常类型
          - java.io.IOException

代码

@Service
public class PaymentService {

    @Retry(name = "paymentService", fallbackMethod = "processPaymentFallback")
    public String processPayment(String orderId) {
        if (Math.random() > 0.3) {
            throw new IOException("Payment Gateway Error");
        }
        return "Payment Success: " + orderId;
    }

    public String processPaymentFallback(String orderId, Exception ex) {
        return "Fallback: " + orderId;
    }
}

限流（Rate Limiter）

限制单位时间内的请求速率：通过令牌桶算法或漏桶算法，控制请求的流量。
实现方式：
令牌桶算法：以固定速率生成令牌，请求需获取令牌才能执行。
漏桶算法：强制请求以恒定速率执行，平滑处理突发流量。

配置

resilience4j:
  ratelimiter:
    instances:
      orderService:
        limitForPeriod: 5           # 时间窗口内允许的请求数
        limitRefreshPeriod: 1s      # 时间窗口长度
        timeoutDuration: 100ms      # 等待令牌的超时时间

代码

@Service
public class OrderService {

    @RateLimiter(name = "orderService", fallbackMethod = "createOrderFallback")
    public String createOrder(String productId) {
        return "Order Created: " + productId;
    }

    public String createOrderFallback(String productId, Exception ex) {
        return "Too Many Requests: " + productId;
    }
}

隔板（Bulkhead）

限制同一时间的最大并发请求数：通过控制并发执行数量，防止资源耗尽

隔板的两种实现
信号量隔离（SemaphoreBulkhead）
原理：基于信号量（Semaphore）控制并发请求的最大数量。
行为：当并发请求数超过阈值时，立即拒绝新请求（抛出BulkheadFullException），无等待队列。
适用场景：轻量级、低延迟的并发控制，适用于I/O密集型或快速响应的操作。
线程池隔离（FixedThreadPoolBulkhead，已弃用）
原理：通过有界线程池和任务队列限制并发（类似Hystrix的线程隔离）。
行为：任务提交到线程池执行，队列满时拒绝新任务。
状态：Resilience4j官方已弃用此实现，推荐使用信号量隔离或结合其他异步库（如CompletableFuture）管理线程资源。
配置

resilience4j:
  bulkhead:
    instances:
      reportService:
        maxConcurrentCalls: 10      # 最大并发调用数
        maxWaitDuration: 10ms      # 等待进入隔板的超时时间

maxWaitDuration：

当隔板的并发请求数已满（达到 maxConcurrentCalls 限制）时，新请求可以等待其他请求释放资源的最大时间。
默认值：0（即不等待，直接拒绝请求，抛出 BulkheadFullException）。
单位：毫秒（例如 Duration.ofSeconds(2) 表示最多等待 2 秒）。

代码

@Service
public class ReportService {

    @Bulkhead(name = "reportService", fallbackMethod = "generateReportFallback")
    public String generateReport(String reportId) {
        return "Report: " + reportId;
    }

    public String generateReportFallback(String reportId, Exception ex) {
        return "System Busy: " + reportId;
    }
}

组合使用多个容错机制

@Service
public class ProductService {
    // 同时应用熔断 + 重试 + 限流
    @CircuitBreaker(name = "productService", fallbackMethod = "fallback")
    @Retry(name = "productService", fallbackMethod = "fallback")
    @RateLimiter(name = "productService", fallbackMethod = "fallback")
    public String getProduct(String productId) {
        if (Math.random() > 0.5) {
            throw new RuntimeException("Service Error");
        }
        return "Product: " + productId;
    }

    public String fallback(String productId, Exception ex) {
        return "Fallback: " + productId;
    }
}

Hystrix vs Resilience4j

核心特性对比
功能深度对比
熔断器

容错模式
性能对比
资源消耗
Hystrix：线程池隔离需要为每个服务分配独立线程池，线程上下文切换开销大，适合资源充足的中型系统。
Resilience4j：信号量隔离无需创建线程，内存占用低，适合高并发场景和云原生环境。
吞吐量测试
场景：1000并发请求，熔断触发条件相同。
结果：
Resilience4j 吞吐量比 Hystrix 高 30%~50%。
Resilience4j 的 GC 停顿时间更短。