本文的工程事实来自 2026-11-21 一次本地直跑:同一个数字分别送进风控闸门和单位哨兵,得到两组相反的结论。命令、输出、退出码均为原文,可复跑。所有账户、持仓、券商、内部系统名均已泛化;文中出现的数字只有三组公开口径的示例:1.0080、980、1060。不出现任何真实仓位或成交价。

一、同一个数字,两种命运

把 1.0080 这个数字,分别送进两个系统。

第一个是风控闸门。它收下数字,按"元/张"的口径算了一通,吐出:

1
MARGIN=20.8998   TIER=档1   VERDICT=Y

翻成人话:余量还有 20.9 个百分点,落在最宽松的第一档,结论是通过(Y)——放行。

第二个是单位哨兵。它只做一件事:检查送进来的数字,单位对不对。它看到 1.0080,返回:

1
UNIT=SUSPECT   exit 2

翻成人话:你嘴上说这是"元/张",但从量级看它是"元/份",我不认,拒绝往下走。

同一个数字,一个说"余量充足,可以下手",一个说"单位可疑,立刻停"。

如果你只能在看板上看到第一个系统的输出,你会以为一切正常。事实上,这是一个差了一万倍的错误,正被第一个系统当成"安全"盖章放行。

这篇文章要讲的不是某个具体标的、某笔具体交易。讲的是工程事实:一个错了单位的数字,是怎么穿过风控的;两层校验为什么缺一不可;fail-open 和 fail-closed 到底差在哪;为什么"上面那层能拦"不等于"底下这层安全";以及怎么用一条一键入口,把校验顺序钉死到没人能绕过去。

二、根因:单位不是注释,是量纲

错误的核心只有一句话:元/份 和 元/张,差一万倍。

期权合约有一个合约乘数,国内常见的规格是每张合约对应 10000 份基础份额。于是:

  • 1 元/份,换算到"每张",就是 10000 元/张;
  • 反过来,把"元/份"的数字直接当"元/张"用,等于把 10000 元的东西当成 1 块钱。

1.0080 这个数字,如果它的真实身份是元/份,那么它对应的每张价值是 10080 元;但如果下游按元/张去解析它,就得到"每张 1.008 元"这种荒唐的量级。

这里有个特别容易被忽略的事实:单位不是写在旁边的一句注释,它是数字的一部分。 一个脱离了单位的浮点数,是没有意义的。你把 1.0080 从 A 函数传到 B 函数,如果中间只传了数字没传单位,那么接收方只能"猜"单位——而风控系统里,猜测等于埋雷。

更麻烦的是,量级错误不会让程序崩溃。1.0080 是一个完全合法的浮点数,类型检查通过、非空检查通过、范围检查(如果你只检查大于 0)也通过。它不会抛异常,不会让日志变红,不会触发告警。它安安静静地流进闸门,然后闸门非常"配合"地给出了一个漂亮结论。

这就是量纲错误最危险的地方:它不报错,它说谎。

三、风控闸门怎么算出"安全"的

闸门的工作是:给定一个输入价格,算出离某条风险线还有多少余量(MARGIN),再按余量分档(TIER),最后给一个能不能放行的结论(VERDICT)。

内部公式属于不该外泄的实现细节,这里不展开,也不该展开——因为即便把公式贴出来,也掩盖不了一个事实:公式本身没错,错的是喂给它的单位。 一个正确的公式,接收了错误量纲的输入,会非常忠实地产出一个错误的结论。

用脱敏后的调用形态看这三组数据:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
# 伪代码:只展示接口与返回,不展示内部公式
# gate(price_yuan_per_share_or_zhang) -> (margin, tier, verdict)

# 场景 A:把 1.0080 当成"元/张"喂进闸门
margin, tier, verdict = gate(1.0080)
print(f"MARGIN={margin} / {tier} / VERDICT={verdict}")
# MARGIN=20.8998 / 档1 / VERDICT=Y

# 场景 B:正确的元/张输入 980
margin, tier, verdict = gate(980)
print(f"MARGIN={margin} / {tier}")
# MARGIN=1.2791 / 档1

# 场景 C:正确的元/张输入 1060
margin, tier, verdict = gate(1060)
print(f"MARGIN={margin} / {tier} N")
# MARGIN=-0.3242 / 档3 N

看这三组输出的对比:

  • 1.0080 被当成元/张时,MARGIN=20.8998,余量巨大,档1,Y;
  • 真正正确的元/张值,比如 980,MARGIN 只有 1.2791,刚刚够,档1;
  • 再高一点的 1060,MARGIN=-0.3242 变成负数,掉到档3,结论是 N(不放行)。

1.0080 和 980、1060 根本不是一个量级的东西。前者是"元/份"的数字被误当成"元/张",后两者才是真正的元/张口径。闸门拿到 1.0080 时,看到的不是一个"很便宜所以很安全"的标的,而是一个被缩小了一万倍的价格。价格越小,算出来的余量越大——于是它信心满满地盖了放行章。

闸门没有坏。闸门被喂错了东西,然后诚实地把错误放大成了一个"安全"的结论。

四、fail-open 与 fail-closed:差一个字,差一条命

这里必须讲清楚两个词:fail-open 和 fail-closed。它们是两套截然相反的容错哲学。

fail-open(失败即放行):当系统遇到异常、缺失、不确定时,默认选择"通过"。设计者的朴素想法是"别因为一点小问题就挡住正常流程"。风控闸门在这个场景里就是 fail-open 的——因为单位错误在它内部表现为"输入价格极小",而极小价格不会触发任何风险规则,于是默认落在"安全、放行"这一侧。它不会因为"我拿到的数字量级不太对"而拒绝,它只会就着这个数字继续算,算出一个漂亮结论。

fail-closed(失败即拒绝):当系统遇到异常、缺失、不确定时,默认选择"不通过"。单位哨兵就是 fail-closed 的——它不确定这个数字的单位对不对,于是宁可错杀,返回 UNIT=SUSPECT 和 exit 2,把流程拦在门口。

两者的差别,用一句话概括:

1
2
fail-open  : 不确定 → 当作没事 → 放行
fail-closed: 不确定 → 当作有事 → 拦下

对风控系统来说,这个取向不是风格问题,是生死问题。风控的使命是"宁可错拦,不可错放"。一个 fail-open 的风控,等于把安全边界交给了"输入恰好正确"这个前提——而这个前提,恰恰是最不可靠的。只要上游有一处把元/份当成元/张,fail-open 的风控就会摇身一变,成为错误的帮凶:它不仅不拦,还给你盖一个"Y"的章,让你错得心安理得。

这就是为什么 1.0080 的案例那么典型:闸门 Y 的结论,比没有闸门更危险。没有闸门,你会警惕;有了闸门说"安全",你会放心地错下去。

五、为什么"包装层能拦"不等于"本体安全"

有人会说:既然单位哨兵能拦住 1.0080,那系统整体就是安全的,闸门就算是 fail-open 也无妨——反正上面有人兜着。

这个想法是错的,而且是那种"平时看不出、出事就是大事"的错。原因有三层。

第一层:兜底的那层,不是每次都在场。 哨兵是独立的一道校验,调用方完全可能绕过它,直接调闸门。今天写的新脚本直连了闸门,忘了挂哨兵;明天某个紧急手动操作图省事,跳过了哨兵;后天某个定时任务用的是旧路径。只要有一次绕过去,fail-open 的闸门就裸奔了。“有人兜着"的前提是"每次都兜住”,而工程现实里,“每次"是最贵的三个字。

第二层:包装层的规则会变,本体的缺陷不变。 哨兵的检测逻辑可能因为业务调整被放宽、被注释掉、被"临时关闭两小时"然后忘了开回来。闸门内部的 fail-open 倾向却一直躺在那里,纹丝不动。把安全性寄托在一个会变的包装层上,等于把地基打在浮沙上。

第三层,也是最本质的:本体 fail-open 是一个错误的设计,不该因为外面有补丁就合理化。 一个风控闸门,即使永远被哨兵保护着,它自己也应该是 fail-closed 的。因为"本体在错误输入下给出安全结论"这件事,本身就是不可接受的——它是系统里的一个定时炸弹,只是暂时被上面那层盖子压着。盖子一旦掀开,炸弹就醒。

所以正确的态度不是"有哨兵兜底就够了”,而是两层都要各自站得住:

  • 闸门本体要对"量级明显异常"的输入保持警惕,能拒绝就拒绝;
  • 哨兵要在闸门之前,独立地、专门地做单位判定;
  • 两者都不能单独作为唯一防线。

“包装层能拦"是一个运行时的偶然,“本体安全"是一个设计上的必然。工程要做的是把偶然变成必然,而不是相反。

六、两层校验为什么必须同时存在

那么问题来了:既然哨兵能做单位判定,为什么还要闸门自己也有一层?既然闸门能算余量,为什么还要哨兵?

因为两者检查的根本不是同一件事,不可互相替代。

单位哨兵回答的问题是:“这个数字的单位,和声明的一致吗?” 它的输入是数字 + 声明的单位,输出是"一致 / 可疑”。它不懂业务风险,不知道余量该怎么算,它只认量纲。1.0080 声明成元/张,量级对不上,直接 UNIT=SUSPECT。它卫的是"输入语义"这道门。

风控闸门回答的问题是:“在给定价格下,离风险线还有多远?” 它的输入是一个已经被确认过单位的数字,输出是余量、档位、放行结论。它不懂单位,它假定送进来的数字已经是正确口径。它卫的是"业务风险"这道门。

把这两件事混成一件事,是常见的设计错误。有人想在闸门里顺手做单位检查,结果闸门的单位逻辑和业务公式搅在一起,改一处动全身;有人想让哨兵顺便算余量,结果哨兵变成第二个闸门,两处公式漂移,对不上账。

正确的分工是清晰的:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
调用方
  │  (数字 + 声明单位)
  ▼
单位哨兵  ── UNIT=SUSPECT / exit 2 ──▶ 拒绝,流程终止
  │  (单位已确认的数字)
  ▼
风控闸门  ── MARGIN / TIER / VERDICT ──▶ Y 或 N
  │
  ▼
下游动作

哨兵在前,闸门在后。哨兵保证"进闸门的数是干净的”,闸门保证"干净的数被正确评估风险"。前者管语义正确,后者管业务正确。缺了前者,闸门会被脏数据喂出漂亮谎话;缺了后者,干净数据也没人告诉我们风险几何。

两层都存在,且顺序固定,才构成一个闭环。

七、一键入口:把顺序钉死到没人能绕

光有正确的设计不够,还得让错误的使用方式"用不出来"。

人总会图省事,总会绕路。如果系统给的是两个独立的函数——一个哨兵、一个闸门——调用方就得自己记住"先调哨兵,再调闸门"。只要这件事需要人记,就一定有人忘。

解法是:不要暴露两个函数,只暴露一个入口。 这个入口内部把顺序写死:先跑哨兵,哨兵不过直接返回;哨兵过了,再跑闸门。调用方拿到手的就是一条"一键通道",它想绕也绕不过去,因为底层根本没给它单独调闸门的路。

用脱敏伪代码表达这个入口:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def risk_check(value, declared_unit):
    """一键入口:单位哨兵在前,风控闸门在后,顺序写死不可绕。"""
    # 第一步:单位哨兵,fail-closed
    ok, unit_verdict = unit_sentry(value, declared_unit)
    if not ok:
        return {
            "pass": False,
            "reason": "UNIT_SUSPECT",
            "detail": unit_verdict,   # UNIT=SUSPECT
            "exit": 2,
        }

    # 第二步:只有单位确认无误,才进风控闸门
    # 闸门只接收已经确认过单位的数字
    margin, tier, verdict = gate(value)
    return {
        "pass": verdict == "Y",
        "reason": "GATE",
        "margin": margin,             # 如 1.2791 / -0.3242
        "tier": tier,                 # 如 档1 / 档3
        "verdict": verdict,           # Y 或 N
        "exit": 0,
    }

现在看 1.0080 走这条入口会发生什么:

1
2
3
4
risk_check(1.0080, "元/张")
  → 哨兵:UNIT=SUSPECT
  → 直接返回 pass=False, exit=2
  → 闸门根本没被调用,那个漂亮的 MARGIN=20.8998 永远不会出现

这就是一键入口的价值:它把"正确的顺序"从一条需要人遵守的规范,变成了一段不可能被违反的代码。调用方不需要记得先查单位——它只要走这个入口,单位检查就一定会发生。

再补三条工程细节,把这个入口做扎实:

  1. 哨兵失败必须是硬失败。 返回 exit 2 后,流程要真的终止,不能"记录一下然后继续"。任何"warning 但不阻断"的写法,都是把 fail-closed 偷偷改回 fail-open。

  2. 闸门入参强制带单位标签。 哪怕经过哨兵,传给闸门的结构体里也要带上已确认的单位字段,而不是裸传一个 float。这样即便未来有人重构、把闸门单独暴露出去,单位信息也不会在传递中丢失。

  3. 入口要有一条端到端用例。 用 1.0080 做输入,断言结果是 UNIT=SUSPECT / exit 2,并且断言闸门没被调用。这条用例钉死"哨兵在前"这个顺序,谁改顺序谁红灯。

八、复算:三组数字,三种结论

把三组公开口径的数字放进这套体系,结论如下(实测原文):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
# 场景 A:错误单位——元/份的数字当成元/张
PS> .\unit_sentry.exe --value 1.0080 --unit 元/张
UNIT=SUSPECT
exit 2

# 若绕过哨兵,直接问闸门(错误示范,仅用于说明 fail-open 的危害)
PS> .\risk_gate.exe --value 1.0080
MARGIN=20.8998 / 档1 / VERDICT=Y

# 场景 B:正确的元/张输入
PS> .\risk_gate.exe --value 980
MARGIN=1.2791 / 档1

# 场景 C:更高的元/张输入
PS> .\risk_gate.exe --value 1060
MARGIN=-0.3242 / 档3 N

四行输出,讲完了整个故事:

  • 哨兵看 1.0080,说 SUSPECT——单位不对,exit 2。
  • 但闸门如果单独拿到 1.0080,会给出 MARGIN=20.8998 / 档1 / Y——一个极具迷惑性的"安全"结论。
  • 真正正确的元/张值 980,余量只有 1.2791,档1,勉强安全。
  • 再往上 1060,余量转负 -0.3242,掉到档3,N。

20.8998 和 1.2791 之间的差距,不是风险变小了,是单位错了。一个错误单位的数字,被 fail-open 的闸门翻译成了一个"更安全"的假象——风控在这里说的不是真话,是谎话。而让他说谎的,不是公式,是我们喂给它的那个没有单位的数字。

九、可以带走的工程原则

从这个案例里,能沉淀出几条普适的原则,和具体业务无关:

1. 数值必须带单位传递。 函数之间不要裸传 float,传的是"数值 + 单位"的二元组或结构体。单位在传递中丢失,是量纲错误的温床。

2. 校验层的默认取向是 fail-closed。 凡涉及安全、风控、权限,不确定时一律拒绝。fail-open 只适合"挡住正常流程的代价大于放过一个坏输入"的场景,而风控恰恰相反。

3. 包装层能拦,不等于本体安全。 每一层都要独立站得住。把安全性寄托在"总有人兜底"上,是把偶然当必然。

4. 顺序也是逻辑,要写进代码而不是文档。 需要人记住的规范,迟早会被违反。用一个一键入口把顺序固化,让错误用法在结构上不可达。

5. 用异常量级做断言。 为 1.0080 这类"声明单位与量级明显不符"的输入,写一条专门的端到端用例。它守的不是某个公式,而是整套校验的顺序和取向。

6. 错误输入下的输出,比正确输入更值得测。 正确输入人人会测;真正暴露设计缺陷的,是"喂进去一个错东西,系统会怎么反应"。闸门对 1.0080 的反应,暴露的正是它的 fail-open 本性。

十、结语

1.0080 本身没有问题。它是一个再普通不过的浮点数。

问题出在:我们把一个元/份的数字,当成元/张送进了闸门;而闸门是一个 fail-open 的系统,它不会质疑输入,只会就着错误算出"安全"。于是,一个差了一万倍的错误,被盖上了 Y 的放行章。

挡住它的,不是闸门,而是闸门之前那道不起眼的单位哨兵——一个只认量级、不懂业务、宁可错杀的 fail-closed 小门。

风控说谎的时候,往往不是它想骗你,而是你给了它一个没有单位的数字,又指望它替你把单位猜对。别让系统猜。把单位写进数据,把哨兵放在闸门前面,把顺序钉死在一键入口里。

这样,风控才会说真话。


本文所有命令与输出均为本地直跑原文,数字仅使用 1.0080 / 980 / 1060 三组公开口径示例,已做脱敏处理。