设计模式之【 断路器模式】

断路器模式实现

在微服务架构中，服务间的依赖调用无处不在，一旦某个依赖服务出现故障（如响应超时、服务宕机），若持续向其发送请求，会导致自身服务资源被耗尽（如线程池满、连接泄漏），进而引发级联故障，最终导致整个系统崩溃。断路器模式（Circuit Breaker Pattern）正是为解决这一问题而生的容错设计模式，它如同现实中的电路断路器，当检测到"故障电流"（依赖服务频繁失败）时，会自动"跳闸"，切断故障依赖的调用链路，避免故障扩散，同时定期尝试"合闸"，恢复正常的服务调用。

简单来说，断路器模式的核心价值的是：防雪崩、保资源、促恢复，是微服务容错体系中不可或缺的核心组件------很多人常说的"微服务熔断"，本质上就是断路器模式的落地实现。

一、实现思路拆解

断路器的实现核心围绕「状态管理」展开，配合参数配置、计数控制和超时机制，确保在多线程环境下安全、高效地完成故障隔离与服务恢复。具体可拆解为「状态定义」「核心参数」「逻辑流程」三个核心模块。

1. 核心状态定义（三种状态，循环切换）

断路器的整个工作周期，就是在三种核心状态之间切换，每种状态对应明确的行为逻辑，避免无效调用和资源浪费。我们可以用枚举清晰定义这三种状态（对应实际开发中的"断开、半断、闭合"）：

• 关闭状态（CLOSED，闭合）：断路器的正常工作状态，此时依赖服务被认为是可用的。所有请求会正常转发到依赖服务，同时内部会实时记录请求的失败次数（成功则重置失败计数），为状态切换提供依据。

• 打开状态（OPEN，断开）：故障状态，当依赖服务的失败次数达到预设阈值时，断路器会"跳闸"，进入打开状态。此时所有请求会被直接拒绝（不转发到依赖服务），直接返回失败响应（可自定义降级逻辑，如返回缓存数据、默认值），避免持续请求耗尽自身服务资源。

• 半开状态（HALF_OPEN，半断）：过渡状态，是连接"打开"与"关闭"的桥梁。打开状态持续一段时间（超时时间）后，断路器会自动切换到半开状态，目的是安全地尝试恢复依赖服务------此时会允许少量请求（预设尝试次数）转发到依赖服务，检测服务是否已恢复。

2. 核心配置参数（控制状态切换的关键）

断路器的行为的由一组核心参数控制，参数配置的合理性直接影响容错效果，实际开发中需结合业务场景（如依赖服务的稳定性、接口响应时间）灵活调整，核心参数如下：

• 失败阈值：关闭状态下，允许的最大失败次数。当失败次数达到该阈值时，断路器立即切换为打开状态（例：10次请求中失败8次，阈值设为8则触发跳闸）。

• 超时时间（打开状态持续时间）：打开状态的维持时间，超时后自动切换为半开状态。目的是给依赖服务一定的恢复时间，避免频繁试探（例：超时时间设为5秒，即打开状态维持5秒后，进入半开状态）。

• 半开状态尝试次数：半开状态下，允许转发到依赖服务的最大请求数。用于检测依赖服务是否恢复，若这些尝试请求中成功次数达到预设标准（通常为全部成功），则切换为关闭状态；若有失败，则立即切换回打开状态（例：尝试次数设为3，3次请求全部成功则恢复，1次失败则重新跳闸）。

3. 核心逻辑流程（状态切换完整链路）

断路器的工作流程本质是"状态检测→计数统计→超时判断→状态切换"的循环，结合三种状态的行为，完整逻辑如下，可直接对应实际开发中的代码逻辑：

1. 关闭状态（CLOSED）流程：

• 接收请求，正常转发到依赖服务；

• 若请求成功：重置失败计数器（失败次数清零），维持关闭状态；

• 若请求失败：失败计数器累加1；

• 判断失败次数是否达到「失败阈值」：若是，立即切换为打开状态；若否，继续维持关闭状态。

2. 打开状态（OPEN）流程：

• 接收请求，直接拒绝（不转发到依赖服务），返回失败响应（可执行降级逻辑）；

• 启动超时计时器，记录打开状态的持续时间；

• 当持续时间达到「超时时间」，自动切换为半开状态。

3. 半开状态（HALF_OPEN）流程：

• 接收请求，按照「半开状态尝试次数」，允许少量请求转发到依赖服务；

• 若尝试请求全部成功：重置失败计数器，切换为关闭状态，恢复正常请求转发；

• 若尝试请求中有任意一次失败：失败计数器重置为阈值（或累加后达到阈值），立即切换回打开状态，重新进入超时等待；

• 若尝试次数用完仍未达到"全部成功"标准：同样切换回打开状态。

二、实现核心要点

1. 线程安全是前提：断路器会被多线程同时调用（如微服务中多个请求并发调用依赖服务），因此失败计数器、状态标识必须保证原子性（可使用原子类，如Java中的AtomicInteger、AtomicReference），避免出现"计数错乱""状态切换异常"（例：多线程同时修改失败次数，导致阈值判断错误）。

2. 状态管理要严谨：三种状态的切换必须遵循固定逻辑，不允许出现"跳跃式切换"（如直接从打开状态切换到关闭状态），同时要避免状态切换的死循环（如半开状态反复失败、反复切换到打开状态，需合理设置超时时间和尝试次数）。

3. 超时控制要精准：打开状态的超时时间需结合依赖服务的恢复能力设置------过短会导致频繁试探，增加系统负担；过长会导致依赖服务恢复后无法及时恢复调用，影响业务可用性。

4. 降级逻辑不可少：打开状态下，直接拒绝请求会影响业务体验，因此需搭配降级逻辑（如返回缓存数据、默认响应、友好提示），确保即使依赖服务故障，自身服务也能正常提供基础功能，提升系统可用性。

三、补充说明

微服务中的"熔断"，本质就是断路器模式的落地实现。比如Spring Cloud中的Resilience4j、Sentinel，其熔断功能的核心逻辑，完全遵循本文所述的断路器模式------通过状态管理、失败计数、超时控制，实现故障隔离和服务恢复。

区别仅在于：框架实现的断路器，还增加了更多实用特性（如滑动窗口计数、熔断后的监控告警、自定义降级策略），但核心原理与我们手动实现的断路器完全一致。因此，理解断路器模式的实现逻辑，是掌握微服务熔断机制的基础。

断路器模式的实现，核心是「状态管理 + 原子计数 + 超时控制」，三者协同工作，实现"故障隔离→试探恢复→正常运行"的闭环。其核心价值在于防止故障扩散、保护系统资源，同时兼顾服务恢复的及时性，是微服务架构中容错设计的核心手段。

四、Demo及日常生产使用

手搓demo

断路器核心类

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 断路器核心实现
 * 状态：关闭(CLOSED) -> 开启(OPEN) -> 半开(HALF_OPEN)
 */
public class CircuitBreaker {
    // 断路器状态枚举
    public enum State {
        CLOSED, OPEN, HALF_OPEN
    }

    // 配置参数
    private final int failureThreshold;    // 失败阈值（连续失败N次触发熔断）
    private final long openTimeout;        // 开启状态超时时间（ms），超时后进入半开
    private final int successThreshold;    // 半开状态成功次数阈值

    // 状态变量（线程安全）
    private volatile State currentState;
    private final AtomicInteger failureCount;   // 失败计数器
    private final AtomicInteger successCount;  // 成功计数器
    private final AtomicLong openStateStartTime;// 开启状态开始时间

    /**
     * 构造方法
     * @param failureThreshold 失败阈值
     * @param openTimeout 熔断超时时间
     * @param successThreshold 半开成功阈值
     */
    public CircuitBreaker(int failureThreshold, long openTimeout, int successThreshold) {
        this.failureThreshold = failureThreshold;
        this.openTimeout = openTimeout;
        this.successThreshold = successThreshold;
        this.currentState = State.CLOSED;
        this.failureCount = new AtomicInteger(0);
        this.successCount = new AtomicInteger(0);
        this.openStateStartTime = new AtomicLong(0);
    }

    /**
     * 执行目标方法（核心入口）
     */
    public <T> T execute(ServiceCallable<T> service) throws Exception {
        // 1. 检查并切换状态
        checkAndSwitchState();

        // 2. 断路器开启状态：直接快速失败
        if (currentState == State.OPEN) {
            System.out.println("【断路器】状态：OPEN → 拒绝请求，快速失败");
            throw new RuntimeException("服务熔断，请求被拒绝");
        }

        // 3. 关闭/半开状态：执行服务调用
        try {
            T result = service.call();
            // 调用成功
            onSuccess();
            return result;
        } catch (Exception e) {
            // 调用失败
            onFailure();
            throw e;
        }
    }

    /**
     * 检查状态并自动切换
     */
    private void checkAndSwitchState() {
        if (currentState == State.OPEN) {
            // 开启状态超时，切换为半开
            long now = System.currentTimeMillis();
            if (now - openStateStartTime.get() >= openTimeout) {
                System.out.println("【断路器】超时恢复 → 状态切换：OPEN → HALF_OPEN");
                currentState = State.HALF_OPEN;
                successCount.set(0);
            }
        }
    }

    /**
     * 调用成功处理
     */
    private void onSuccess() {
        switch (currentState) {
            case CLOSED:
                // 关闭状态：重置失败计数
                failureCount.set(0);
                break;
            case HALF_OPEN:
                // 半开状态：累计成功次数
                if (successCount.incrementAndGet() >= successThreshold) {
                    System.out.println("【断路器】服务恢复 → 状态切换：HALF_OPEN → CLOSED");
                    currentState = State.CLOSED;
                    failureCount.set(0);
                    successCount.set(0);
                }
                break;
            default:
                break;
        }
    }

    /**
     * 调用失败处理
     */
    private void onFailure() {
        switch (currentState) {
            case CLOSED:
                // 关闭状态：累计失败，达到阈值则熔断
                if (failureCount.incrementAndGet() >= failureThreshold) {
                    System.out.println("【断路器】失败达阈值 → 状态切换：CLOSED → OPEN");
                    currentState = State.OPEN;
                    openStateStartTime.set(System.currentTimeMillis());
                }
                break;
            case HALF_OPEN:
                // 半开状态：只要失败，立即重新熔断
                System.out.println("【断路器】半开调用失败 → 状态切换：HALF_OPEN → OPEN");
                currentState = State.OPEN;
                openStateStartTime.set(System.currentTimeMillis());
                successCount.set(0);
                break;
            default:
                break;
        }
    }

    // 函数式接口：定义服务调用逻辑
    @FunctionalInterface
    public interface ServiceCallable<T> {
        T call() throws Exception;
    }

    // 获取当前状态（测试用）
    public State getCurrentState() {
        return currentState;
    }
}

测试主类

/**
 * 断路器模式测试 Demo
 */
public class CircuitBreakerDemo {
    // 模拟远程服务调用（随机失败，模拟服务异常）
    private static String callRemoteService(boolean shouldFail) throws Exception {
        if (shouldFail) {
            System.out.println("【服务调用】失败");
            throw new Exception("远程服务超时/异常");
        }
        System.out.println("【服务调用】成功");
        return "服务返回结果";
    }

    public static void main(String[] args) throws InterruptedException {
        // 初始化断路器：失败3次熔断，熔断5秒后进入半开，半开连续2次成功则恢复
        CircuitBreaker breaker = new CircuitBreaker(3, 5000, 2);

        System.out.println("===== 第一阶段：连续调用失败，触发熔断 =====");
        // 模拟连续失败
        for (int i = 0; i < 5; i++) {
            try {
                breaker.execute(() -> callRemoteService(true));
            } catch (Exception e) {
                System.out.println("请求异常：" + e.getMessage() + "\n");
            }
        }

        System.out.println("===== 第二阶段：断路器开启，直接拒绝请求 =====");
        // 断路器开启，所有请求直接被拒
        for (int i = 0; i < 2; i++) {
            try {
                breaker.execute(() -> callRemoteService(false));
            } catch (Exception e) {
                System.out.println("请求异常：" + e.getMessage() + "\n");
            }
        }

        System.out.println("===== 第三阶段：等待5秒，进入半开状态 =====");
        // 等待超时，进入半开
        Thread.sleep(5000);

        System.out.println("===== 第四阶段：半开状态，尝试成功调用 =====");
        // 半开状态连续成功，恢复关闭状态
        for (int i = 0; i < 3; i++) {
            try {
                breaker.execute(() -> callRemoteService(false));
            } catch (Exception e) {
                System.out.println("请求异常：" + e.getMessage());
            }
            System.out.println();
        }

        System.out.println("===== 第五阶段：断路器恢复关闭，正常调用 =====");
        try {
            breaker.execute(() -> callRemoteService(false));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行效果说明
执行代码后，你会看到完整的状态流转：
连续失败 3 次 → 断路器从 CLOSED → OPEN
熔断期间 → 所有请求直接快速失败
等待 5 秒超时 → 断路器从 OPEN → HALF_OPEN
连续成功 2 次 → 断路器从 HALF_OPEN → CLOSED
恢复正常 → 服务正常调用

生产级推荐使用成熟框架

Resilience4j（SpringCloud 官方推荐）

Sentinel（阿里开源，更轻量）

Hystrix（Netflix 老牌，已停更）

业务 Service（核心）使用 @SentinelResource 定义熔断资源 + 降级方法。

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.stereotype.Service;

@Service
public class TestService {

    /**
     * 定义 Sentinel 资源
     * value = 资源名称（自定义）
     * blockHandler = 限流/熔断时走的降级方法
     */
    @SentinelResource(value = "remoteService", blockHandler = "fallbackHandler")
    public String callRemoteService(boolean fail) {
        // 模拟远程调用异常
        if (fail) {
            throw new RuntimeException("远程服务调用失败！");
        }
        return "远程服务调用成功 ✅";
    }

    /**
     * 降级/兜底方法（参数最后必须加 BlockException）
     */
    public String fallbackHandler(boolean fail, BlockException ex) {
        return "服务熔断/限流 → 已降级 ✅";
    }
}

控制层（测试接口）

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    @Autowired
    private TestService testService;

    // 测试：fail=true 触发失败
    @GetMapping("/test")
    public String test(@RequestParam(defaultValue = "false") boolean fail) {
        return testService.callRemoteService(fail);
    }
}

配置熔断规则

import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.Collections;

@Component
public class SentinelConfig {

    @PostConstruct
    public void initDegradeRule() {
        DegradeRule rule = new DegradeRule();
        rule.setResource("remoteService"); // 对应 @SentinelResource 的名称
        
        // 熔断策略：异常比例
        rule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO);
        
        // 异常比例 50% 触发熔断
        rule.setCount(0.5);
        
        // 熔断 5 秒后进入半开探测
        rule.setTimeWindow(5);
        
        // 加载规则
        DegradeRuleManager.loadRules(Collections.singletonList(rule));
        System.out.println("Sentinel 熔断规则加载完成 ✅");
    }
}

Sentinel 控制台（可视化监控）
地址

启动：java -jar sentinel-dashboard-1.8.6.jar