Go math/bits.Sub64 怎样传递多字长减法的借位

在做分片计数器、定长 ID 或底层二进制协议时，一个逻辑整数可能由多个 uint64 组成。此时直接写减法，最容易漏掉的不是差值本身，而是低位减法产生的借位。

Go 的 math/bits.Sub64 正好把这件事拆成两个返回值：diff 是当前 64 位字的差值，borrowOut 是是否需要向更高位继续借位。多字长减法的固定顺序是：低位先算，再把借位原样传给高位。

核心写法：diff = x - y - borrow，输入 borrow 只能是 0 或 1；最后一段返回的 borrowOut 为 1 时，表示整个无符号数发生了下溢。

为什么不能把两个 uint64 结果各算各的

把 128 位数写成 A = (a1, a0)、B = (b1, b0)，其中下标 1 是高 64 位、下标 0 是低 64 位。低位如果出现 a0 ，低位仍然可以用模 264 的方式得到一个结果，但高位必须再减 1。

如果高位直接计算 a1 - b1，就等价于把低位借走的 1 丢掉。这个错误在普通样例中不明显，直到低 64 位刚好跨过 0，最终结果才会差一个高位单位。

低位先调用 Sub64，拿到 0 或 1

第一次调用的第三个参数表示“更低一段已经借走了多少”。对于最低段，没有更低段，所以传入 0：

package main

import "math/bits"

func lowWord(a0, b0 uint64) (uint64, uint64) {
	// 最低字没有更低一段，初始 borrow 必须为 0。
	diff, borrow := bits.Sub64(a0, b0, 0)
	// borrow 只会是 0 或 1，下一段要原样接收它。
	return diff, borrow
}

不要把第三个参数理解成“是否允许借位”。它是当前这一段已经从更低位借入的数量。最低段传入非 0 值会改变计算式，而且官方文档明确要求该参数只能为 0 或 1。

把低位借位接到高位

高位调用时，把低位返回的 borrow 作为第三个参数传入。下面的封装把一个 128 位风格的无符号数表示成高低两个字：

package wide

import "math/bits"

// Uint128Parts 用两个 uint64 表示一个无符号多字长整数。
type Uint128Parts struct {
	Hi uint64 // 高 64 位
	Lo uint64 // 低 64 位
}

// Sub 计算 a-b，并返回结果以及是否发生整体下溢。
func Sub(a, b Uint128Parts) (Uint128Parts, uint64) {
	// 先减低位，得到需要传给高位的借位。
	lo, borrow := bits.Sub64(a.Lo, b.Lo, 0)
	// 高位必须减去低位借来的 1，最终 borrow 表示整体下溢。
	hi, borrowOut := bits.Sub64(a.Hi, b.Hi, borrow)
	return Uint128Parts{Hi: hi, Lo: lo}, borrowOut
}

这段代码最重要的不是结构体，而是调用顺序：Lo 的 borrow 只进入 Hi 的第三个参数，不能把它加到高位的被减数或减数中，也不能把两个返回值交换。

局部借位和整体下溢不是一回事

低位产生借位，并不代表整个 128 位的 A 小于 B。例如，高位相等时低位发生借位，最终高位会把这个借位消化掉；只有高位那次 Sub64 返回的 borrowOut 为 1，才表示整体结果在无符号语义下小于 0。

可以用下面三条规则读返回值：

用表格测试覆盖跨字边界

测试重点应放在低位跨 0、高位相等和整体下溢三类边界，而不是只测试普通差值。示例把结果与最终借位一起断言：

package wide_test

import (
	"testing"

	"example.com/wide"
)

func TestSubBorrowAcrossWords(t *testing.T) {
	tests := []struct {
		name string
		a, b wide.Uint128Parts
		want wide.Uint128Parts
		underflow uint64
	}{
		// 低位借位后由相等的高位吸收，整体仍不下溢。
		{"low-borrow", wide.Uint128Parts{Hi: 4, Lo: 0}, wide.Uint128Parts{Hi: 3, Lo: 1}, wide.Uint128Parts{Hi: 0, Lo: ^uint64(0)}, 0},
		// 被减数整体更小，最高段会留下最终借位。
		{"whole-underflow", wide.Uint128Parts{Hi: 2, Lo: 0}, wide.Uint128Parts{Hi: 3, Lo: 0}, wide.Uint128Parts{Hi: ^uint64(0), Lo: 0}, 1},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, underflow := wide.Sub(tt.a, tt.b)
			if got != tt.want || underflow != tt.underflow {
				t.Fatalf("got=%#v, borrow=%d", got, underflow)
			}
		})
	}
}

示例中的导入路径 example.com/wide 只是包名占位；接入项目时换成实际模块路径即可。测试里专门保留 Lo=0 和 Hi 变化，是为了让借位链真正跨过 64 位边界。

工程上需要记住的三个取舍

1. 返回值要成对保留。差值和借位是一组契约，只保留 diff 会丢失整体大小关系。
2. 借位只沿字宽方向传播。从低字到高字逐段调用，不能从高字开始，也不要把 borrow 当普通布尔开关传入未经归一化的整数。
3. 无符号下溢要由调用方决定语义。最终 borrowOut 可以用来判断 A 是否小于 B，但如果业务要饱和减法、报错或转成有符号结果，需要在外层明确处理。

相关问题

Sub64 的 borrow 参数可以传 2 吗？

不可以。官方契约要求输入借位只能是 0 或 1；多字长计算应传入上一段 Sub64 的 borrowOut。

低位返回 borrowOut 为 1，是否说明整个数下溢？

不一定。它只说明低位这一段不够减，最终是否下溢要看最高段调用返回的 borrowOut。

为什么不直接用 big.Int？

如果数值宽度动态变化或需要完整大整数运算，应评估 math/big。固定两段或少量机器字的场景使用 Sub64 可以保持数据布局明确，但借位传播和边界测试要由调用方负责。

把 Sub64 当作“当前字的减法 + 向更高字报告借位”即可。先算低位、再传借位、最后读取最高位的 borrowOut，这个顺序就是多字长无符号减法的稳定骨架。