// 应用代码
Entry entry = null;
try {
    entry = SphU.entry("myResource");  // 获取入口
    // ↓ Slot Chain 依次执行
    // NodeSelectorSlot.entry() → pass
    // ClusterBuilderSlot.entry() → pass
    // StatisticSlot.entry() → 记录请求开始
    // FlowSlot.entry() → 检查是否限流 → pass/block
    // DegradeSlot.entry() → 检查是否熔断 → pass/block
    
    // 业务逻辑
    doSomething();
    
} catch (BlockException e) {
    // 被限流或熔断 → 执行降级逻辑
    handleFallback();
} finally {
    if (entry != null) {
        entry.exit();  // StatisticSlot 记录响应时间和成功/失败
    }
}

// 源码路径: com.alibaba.csp.sentinel.slots.statistic.base.LeapArray

public abstract class LeapArray<T> {
    
    // 小窗口长度（毫秒）
    protected int windowLengthInMs;
    
    // 小窗口数量
    protected int sampleCount;
    
    // 统计周期（毫秒）= windowLengthInMs * sampleCount
    protected int intervalInMs;
    
    // 核心：环形数组，存储所有小窗口
    protected final AtomicReferenceArray<WindowWrap<T>> array;
}

// 源码路径: com.alibaba.csp.sentinel.slots.statistic.data.MetricBucket

public class MetricBucket {
    // 使用 LongAdder 实现高并发无锁累加
    private final LongAdder[] counters;
    
    // 统计维度枚举
    // PASS: 通过的请求数
    // BLOCK: 被拒绝的请求数
    // EXCEPTION: 异常请求数
    // SUCCESS: 成功请求数
    // RT: 总响应时间（用于计算平均 RT）
    // OCCUPIED_PASS: 预占通过数
}

// 源码路径: LeapArray#currentWindow(long timeMillis)

public WindowWrap<T> currentWindow(long timeMillis) {
    if (timeMillis < 0) {
        return null;
    }
    
    // 1. 计算当前时间落在哪个窗口（取模定位）
    int idx = calculateTimeIdx(timeMillis);
    long windowStart = calculateWindowStart(timeMillis);
    
    // 2. 自旋 + CAS 获取/创建窗口
    while (true) {
        WindowWrap<T> old = array.get(idx);
        
        if (old == null) {
            // Case 1: 该位置为空 → 创建新窗口
            WindowWrap<T> window = new WindowWrap<>(
                windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
            if (array.compareAndSet(idx, null, window)) {
                return window;  // CAS 成功，返回新窗口
            } else {
                Thread.yield();  // CAS 失败，让出 CPU 重试
            }
            
        } else if (windowStart == old.windowStart()) {
            // Case 2: 窗口存在且未过期 → 直接复用
            return old;
            
        } else if (windowStart > old.windowStart()) {
            // Case 3: 窗口已过期 → 重置复用（关键！）
            if (updateLock.tryLock()) {
                try {
                    return resetWindowTo(old, windowStart);
                } finally {
                    updateLock.unlock();
                }
            } else {
                Thread.yield();
            }
        }
        // Case 4: windowStart < old.windowStart() 
        // 时钟回拨，理论上不应该发生
    }
}

// 时间轮索引计算
private int calculateTimeIdx(long timeMillis) {
    long timeId = timeMillis / windowLengthInMs;
    return (int)(timeId % array.length());
}

// 窗口起始时间计算
private long calculateWindowStart(long timeMillis) {
    return timeMillis - timeMillis % windowLengthInMs;
}

// 重置过期窗口
private WindowWrap<T> resetWindowTo(WindowWrap<T> w, long startTime) {
    // 重置窗口起始时间
    w.resetTo(startTime);
    // 重置统计数据（MetricBucket 内部的 LongAdder 全部归零）
    w.value().reset();
    return w;
}

// 源码路径: com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule

public class DegradeRule extends AbstractRule {
    // 熔断策略
    private int grade;  
    // DEGRADE_GRADE_RT = 0          → 慢调用比例
    // DEGRADE_GRADE_EXCEPTION_RATIO = 1 → 异常比例
    // DEGRADE_GRADE_EXCEPTION_COUNT = 2 → 异常数
    
    private double count;        // 阈值
    private int timeWindow;      // 熔断持续时间（秒）
    private int minRequestAmount; // 最小请求数（防止样本过少误判）
    private double slowRatioThreshold; // 慢调用比例阈值
    private int statIntervalMs;  // 统计周期
}

// 源码路径: com.alibaba.csp.sentinel.slots.block.degrade.circuitbreaker

public interface CircuitBreaker {
    DegradeRule getRule();
    boolean tryPass(Context context);    // 尝试通过
    State currentState();                // 当前状态
    void onRequestComplete(Context context); // 请求完成回调
}

public enum State {
    OPEN,       // 熔断打开
    HALF_OPEN,  // 半开
    CLOSED      // 关闭（正常）
}

public abstract class AbstractCircuitBreaker implements CircuitBreaker {
    
    // 状态：使用 AtomicReference + CAS 保证线程安全
    protected final AtomicReference<State> currentState 
        = new AtomicReference<>(State.CLOSED);
    
    // 探针计数器：HALF_OPEN 时只允许一个探针
    protected final AtomicLong retryTimeoutArrived = new AtomicLong(0);
    
    // 下一次重试时间点
    protected volatile long nextRetryTimestamp;
    
    @Override
    public boolean tryPass(Context context) {
        // 1. CLOSED 状态 → 直接放行
        if (currentState.get() == State.CLOSED) {
            return true;
        }
        
        // 2. OPEN 状态 → 检查是否到达重试时间
        if (currentState.get() == State.OPEN) {
            if (retryTimeoutArrived()) {
                // 尝试从 OPEN 切换到 HALF_OPEN
                if (fromOpenToHalfOpen(context)) {
                    return true;  // 作为探针放行
                }
            }
            return false;  // 未到重试时间，拒绝
        }
        
        // 3. HALF_OPEN 状态 → 拒绝（已有探针在运行）
        return false;
    }
    
    protected boolean retryTimeoutArrived() {
        return TimeUtil.currentTimeMillis() >= nextRetryTimestamp;
    }
    
    // OPEN → HALF_OPEN 的状态切换
    protected boolean fromOpenToHalfOpen(Context context) {
        // CAS 保证只有一个线程能切换
        if (currentState.compareAndSet(State.OPEN, State.HALF_OPEN)) {
            // 通知监听器
            notifyObservers(State.OPEN, State.HALF_OPEN, null);
            return true;
        }
        return false;
    }
    
    // HALF_OPEN → CLOSED 的状态切换
    protected void fromHalfOpenToClosed() {
        if (currentState.compareAndSet(State.HALF_OPEN, State.CLOSED)) {
            resetStat();  // 重置统计窗口
            notifyObservers(State.HALF_OPEN, State.CLOSED, null);
        }
    }
    
    // HALF_OPEN → OPEN 的状态切换（探针失败）
    protected void fromHalfOpenToOpen(double snapshotValue) {
        if (currentState.compareAndSet(State.HALF_OPEN, State.OPEN)) {
            updateNextRetryTimestamp();  // 重新计算下次重试时间
            notifyObservers(State.HALF_OPEN, State.OPEN, snapshotValue);
        }
    }
}

// 源码路径: ResponseTimeCircuitBreaker

public class ResponseTimeCircuitBreaker extends AbstractCircuitBreaker {
    
    private final long maxAllowedRt;       // 慢调用 RT 阈值
    private final double maxSlowRequestRatio; // 慢调用比例阈值
    
    @Override
    public void onRequestComplete(Context context) {
        // 获取本次请求的 RT
        long rt = context.getCurEntry().getRt();
        
        if (currentState.get() == State.HALF_OPEN) {
            // 半开状态：判断探针结果
            if (rt > maxAllowedRt) {
                // 探针是慢调用 → 切回 OPEN
                fromHalfOpenToOpen(1.0);
            } else {
                // 探针成功 → 切到 CLOSED
                fromHalfOpenToClosed();
            }
            return;
        }
        
        // CLOSED 状态：累加统计
        // 记录慢调用
        if (rt > maxAllowedRt) {
            slowCounter.add(1);
        }
        totalCounter.add(1);
        
        // 检查是否达到熔断条件
        handleStateChangeWhenThresholdExceeded(rt);
    }
    
    private void handleStateChangeWhenThresholdExceeded(long rt) {
        // 请求数不足，不做判断
        if (totalCounter.sum() < minRequestAmount) {
            return;
        }
        
        double slowRatio = slowCounter.sum() * 1.0 / totalCounter.sum();
        
        if (slowRatio > maxSlowRequestRatio) {
            // 慢调用比例超阈值 → CLOSED → OPEN
            if (currentState.compareAndSet(State.CLOSED, State.OPEN)) {
                updateNextRetryTimestamp();
                notifyObservers(State.CLOSED, State.OPEN, slowRatio);
            }
        }
    }
}

// 多线程同时到达 HALF_OPEN 入口
Thread-1: currentState.compareAndSet(OPEN, HALF_OPEN) → true  ✓ 探针放行
Thread-2: currentState.compareAndSet(OPEN, HALF_OPEN) → false ✗ 拒绝
Thread-3: currentState.get() == HALF_OPEN → false             ✗ 拒绝

// 指数退避改进（伪代码）
void fromHalfOpenToOpen() {
    consecutiveOpenCount++;
    long backoff = Math.min(
        baseTimeout * (1L << consecutiveOpenCount),
        maxTimeout  // 上限，如 60s
    );
    nextRetryTimestamp = System.currentTimeMillis() + backoff;
}

// 多次确认改进（伪代码）
int requiredSuccessCount = 3;
AtomicInteger probeSuccessCount = new AtomicInteger(0);

void onProbeComplete(boolean success) {
    if (success) {
        if (probeSuccessCount.incrementAndGet() >= requiredSuccessCount) {
            fromHalfOpenToClosed();
        }
        // 否则继续保持 HALF_OPEN，等待下一个探针
    } else {
        probeSuccessCount.set(0);
        fromHalfOpenToOpen();
    }
}

// 渐进式恢复（设计方案）
class GradualRecoveryStrategy {
    private double[] recoverySteps = {0.1, 0.25, 0.5, 0.75, 1.0};
    private int currentStep = 0;
    
    boolean shouldPass(long requestId) {
        double ratio = recoverySteps[currentStep];
        // 按比例放行
        return (requestId % 100) < (ratio * 100);
    }
    
    void onStepSuccess() {
        // 当前比例下成功率达标 → 提升比例
        if (currentStep < recoverySteps.length - 1) {
            currentStep++;
        } else {
            // 100% 放行成功 → 恢复 CLOSED
            circuitBreaker.close();
        }
    }
    
    void onStepFailure() {
        // 当前比例下失败率超标 → 回退到上一步或重新 OPEN
        currentStep = Math.max(0, currentStep - 1);
        if (failureCount > threshold) {
            circuitBreaker.open();
        }
    }
}

class ExponentialBackoffStrategy {
    private long baseTimeout = 5000;   // 5s
    private long maxTimeout = 60000;   // 60s
    private int consecutiveTrips = 0;  // 连续触发次数
    
    long getNextTimeout() {
        long timeout = baseTimeout * (1L << Math.min(consecutiveTrips, 10));
        return Math.min(timeout, maxTimeout);
    }
    
    void onTrip() {
        consecutiveTrips++;
    }
    
    void onRecover() {
        consecutiveTrips = 0;  // 恢复后重置
    }
}

class HealthScoreStrategy {
    // 健康度 = 加权评分
    double calculateHealthScore(NodeMetrics metrics) {
        double rtScore = normalize(metrics.avgRt, 0, 1000);      // RT 评分
        double errorScore = 1.0 - metrics.errorRatio;             // 错误率评分
        double successScore = metrics.successRatio;                // 成功率评分
        
        // 加权
        return rtScore * 0.3 + errorScore * 0.4 + successScore * 0.3;
    }
    
    // 健康度 > 0.7 → CLOSED
    // 健康度 0.3 ~ 0.7 → HALF_OPEN（按比例放行）
    // 健康度 < 0.3 → OPEN
}

// 配置慢调用比例熔断规则
List<DegradeRule> rules = new ArrayList<>();
DegradeRule rule = new DegradeRule("myResource")
    .setGrade(RuleConstant.DEGRADE_GRADE_RT)           // 慢调用比例策略
    .setCount(200)                                       // 慢调用 RT 阈值：200ms
    .setSlowRatioThreshold(0.5)                          // 慢调用比例阈值：50%
    .setMinRequestAmount(10)                             // 最小请求数：10
    .setStatIntervalMs(10000)                            // 统计周期：10s
    .setTimeWindow(5);                                   // 熔断持续时间：5s
rules.add(rule);
DegradeRuleManager.loadRules(rules);

// 使用
Entry entry = null;
try {
    entry = SphU.entry("myResource");
    // 正常业务逻辑
    String result = callDownstreamService();
    return result;
} catch (BlockException e) {
    // 被熔断 → 降级逻辑
    return getDefaultValue();
} finally {
    if (entry != null) {
        entry.exit();
    }
}