熔断恢复机制：半开状态详解

DegradeRule rule = new DegradeRule();
rule.setResource("callRemoteService");
rule.setGrade(RuleConstant.DEGRADE_GRADE_RT);
rule.setCount(1000);
rule.setSlowRatioThreshold(0.5);
rule.setTimeWindow(10); // ← 熔断时长：10秒

// Sentinel内部实现（简化）
public class CircuitBreaker {
    private volatile int state; // 0=Closed, 1=Open, 2=Half-Open
    private AtomicBoolean probing = new AtomicBoolean(false);

    public boolean tryPass() {
        // 1. 如果是关闭状态，直接通过
        if (state == CLOSED) {
            return true;
        }

        // 2. 如果是开启状态，检查是否到达恢复时间
        if (state == OPEN) {
            if (currentTime >= recoveryTime) {
                // 进入半开状态
                state = HALF_OPEN;
            } else {
                // 还在熔断时长内，拒绝
                return false;
            }
        }

        // 3. 如果是半开状态，只允许一个探测请求
        if (state == HALF_OPEN) {
            // CAS操作，保证只有一个线程能设置为true
            if (probing.compareAndSet(false, true)) {
                // 这个请求被选为探测请求
                return true;
            } else {
                // 其他请求继续熔断
                return false;
            }
        }

        return false;
    }
}

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;
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 java.util.ArrayList;
import java.util.List;

public class HalfOpenDemo {

    private static volatile boolean serviceHealthy = false; // 模拟服务健康状态

    public static void main(String[] args) throws InterruptedException {
        initDegradeRule();

        // 启动一个线程，10秒后恢复服务
        new Thread(() -> {
            try {
                Thread.sleep(10000);
                serviceHealthy = true;
                System.out.println("\n⚠️  [10秒] 远程服务已恢复\n");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        // 模拟持续调用
        for (int i = 0; i < 30; i++) {
            Thread.sleep(1000);
            System.out.println("\n--- 第" + (i + 1) + "秒 ---");
            callRemoteService();
        }
    }

    /**
     * 配置慢调用比例熔断规则
     */
    private static void initDegradeRule() {
        List<DegradeRule> rules = new ArrayList<>();
        DegradeRule rule = new DegradeRule();
        rule.setResource("callRemoteService");
        rule.setGrade(RuleConstant.DEGRADE_GRADE_RT);
        rule.setCount(500); // RT > 500ms算慢调用
        rule.setSlowRatioThreshold(0.6); // 慢调用比例60%
        rule.setMinRequestAmount(3);
        rule.setStatIntervalMs(10000);
        rule.setTimeWindow(10); // 熔断10秒
        rules.add(rule);
        DegradeRuleManager.loadRules(rules);
        System.out.println("✅ 熔断规则已加载：RT > 500ms，慢调用比例 > 60%，熔断10秒\n");
    }

    /**
     * 调用远程服务
     */
    private static void callRemoteService() {
        try (Entry entry = SphU.entry("callRemoteService")) {
            // 模拟调用
            if (serviceHealthy) {
                // 服务健康，响应50ms
                Thread.sleep(50);
                System.out.println("✅ 调用成功，响应时间：50ms");
            } else {
                // 服务故障，响应3秒
                Thread.sleep(3000);
                System.out.println("⚠️  调用成功，响应时间：3000ms（慢调用）");
            }
        } catch (BlockException e) {
            // 熔断降级
            System.out.println("🔴 熔断生效，快速失败");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 如果依赖服务通常需要30秒恢复，熔断时长应该设置为40-60秒
rule.setTimeWindow(40);

// 不要设置过低的阈值
rule.setSlowRatioThreshold(0.6); // 60%，留有余量
// 而不是
rule.setSlowRatioThreshold(0.3); // 30%，太敏感

// 增加最小请求数，避免样本太少
rule.setMinRequestAmount(10); // 至少10个请求
// 而不是
rule.setMinRequestAmount(3); // 太少，容易误判

// 第一层：严格熔断
DegradeRule strictRule = new DegradeRule();
strictRule.setResource("callRemoteService");
strictRule.setSlowRatioThreshold(0.8); // 80%
strictRule.setTimeWindow(10);

// 第二层：宽松熔断
DegradeRule looseRule = new DegradeRule();
looseRule.setResource("callRemoteService");
looseRule.setSlowRatioThreshold(0.5); // 50%
looseRule.setTimeWindow(30); // 更长的恢复时间

public class CircuitBreakerSlot extends AbstractLinkedProcessorSlot<DefaultNode> {

    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper,
                      DefaultNode node, int count, boolean prioritized, Object... args)
            throws Throwable {
        // 在这里可以监控熔断器状态
        fireEntry(context, resourceWrapper, node, count, prioritized, args);
    }
}

@SentinelResource(
    value = "callRemoteService",
    blockHandler = "handleBlock"
)
public String callRemoteService() {
    return remoteService.call();
}

public String handleBlock(BlockException ex) {
    if (ex instanceof DegradeException) {
        // 记录熔断事件
        logger.info("熔断器状态：熔断中");
    }
    return "降级数据";
}

// 熔断规则
DegradeRule degradeRule = new DegradeRule();
degradeRule.setResource("callRemoteService");
degradeRule.setGrade(RuleConstant.DEGRADE_GRADE_RT);
degradeRule.setCount(1000);
degradeRule.setTimeWindow(10);

// 流控规则：Warm Up
FlowRule flowRule = new FlowRule();
flowRule.setResource("callRemoteService");
flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
flowRule.setCount(100);
flowRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP);
flowRule.setWarmUpPeriodSec(30); // 30秒预热