从逻辑帧到确定性服务：高并发系统的一致性编码规范（绿皮书）

// 不合格：依赖系统时间 + 随机数
public class RiskScoreCalculator {
    public int calculate(Order order) {
        // 非确定性：当前时间
        long now = System.currentTimeMillis();
        // 非确定性：随机种子未固定
        double factor = Math.random() * 0.5;
        return (int)(order.getAmount() * 0.1 + now % 1000 * factor);
    }
}

// 合格：全部依赖输入参数
public class DeterministicRiskScoreCalculator {
    // 所有外部依赖全部作为参数传入
    public int calculate(Order order, long timestampMillis, Random deterministicRandom) {
        // timestampMillis 由外部调度器统一传入
        // deterministicRandom 使用固定种子构造
        long baseScore = (long)(order.getAmount() * 0.1);
        long timeFactor = timestampMillis % 1000;
        double randFactor = deterministicRandom.nextDouble() * 0.5;
        return (int)(baseScore + timeFactor * randFactor);
    }
}

// 规范强制：金额使用Long表示分
public class AmountCalculator {
    // 费率 0.15% 用放大后的整数表示：15（表示0.15%）
    public long calculateFee(long amountInCents, long feeRateBasisPoints) {
        // 乘法采用 long 精确计算，最后统一缩放
        return amountInCents * feeRateBasisPoints / 10000L;
    }
}

@ArchTest
public static final ArchRule DETERMINISTIC_ITERATION =
    noClasses().should()
        .callMethod(HashSet.class, "iterator")
        .or().callMethod(HashMap.class, "entrySet")
        .because("HashSet/HashMap迭代顺序不确定，必须使用TreeSet或显式排序");

@Service
public class ClockService {
    // 由调度器每帧推进一次
    private long currentFrameTimestamp;
    private long currentFrameIndex;

    // 仅在业务启动/调度时由外部调用，业务代码禁止调用set
    public void tick(long timestamp) {
        this.currentFrameTimestamp = timestamp;
        this.currentFrameIndex++;
    }

    // 业务代码统一使用该方法获取“当前帧时间”
    public long getCurrentFrameTime() {
        return currentFrameTimestamp;
    }

    // 用于压测和回放场景：可重置到任意历史时间点
    public void resetTo(long timestamp, long frameIndex) {
        this.currentFrameTimestamp = timestamp;
        this.currentFrameIndex = frameIndex;
    }
}

@Test
public void testDeterministicConsistency() {
    // 1. 准备相同的输入快照
    List<Event> eventLog = loadEventLog("scenario_001.json");
    long fixedTimestamp = 1700000000000L;
    Random fixedRandom = new Random(12345L);

    // 2. 在多个线程中分别执行
    CompletableFuture<String> resultA = runInIsolatedClassloader(() -> 
        new DeterministicProcessor().process(eventLog, fixedTimestamp, fixedRandom)
    );
    CompletableFuture<String> resultB = runInIsolatedClassloader(() -> 
        new DeterministicProcessor().process(eventLog, fixedTimestamp, fixedRandom)
    );

    // 3. 断言完全一致
    assertEquals(resultA.get(), resultB.get());
}