Go math/rand/v2.ChaCha8 怎样生成可复现随机序列

要让 Go 程序每次生成同一组伪随机结果，关键不是调用全局的 math/rand/v2 函数，而是创建一个独立的 rand.ChaCha8，并给它传入固定的 [32]byte 种子。相同种子、相同调用顺序会得到相同序列；调用顺序改变，后续结果也会跟着改变。

固定种子要写成 [32]byte

math/rand/v2 在 Go 1.22 引入，ChaCha8 的构造函数是 rand.NewChaCha8(seed [32]byte)。它和旧版 math/rand.Seed(int64) 不是同一种接口：种子长度固定为 32 字节，便于把测试输入写成稳定、明确的值。

下面的种子只是示例数据。真正的测试可以按照用例编号、固定字节串或测试 fixture 生成它，但不要把业务密码、访问令牌或用户隐私数据直接塞进种子。

package main

import (
    "fmt"
    "math/rand/v2"
)

func main() {
    // 固定 32 字节种子，让本次模拟具备可重复的起点。
    var seed [32]byte
    copy(seed[:], []byte("order-test-seed-v1"))

    // 每次调用都会创建独立的 ChaCha8 状态，不改写全局随机源。
    source := rand.NewChaCha8(seed)
    fmt.Println(source.Uint64())
    fmt.Println(source.Uint64())
}

这里没有使用全局 rand.Uint64()，因为全局生成器的种子是随机设置的，而且 API 不保证固定的输出序列。把状态放进局部实例，测试用例才有清晰的输入边界。

相同种子与相同调用顺序会复现序列

复现的条件可以写成一句话：种子相同，实例类型相同，调用顺序相同。下面同时创建两个实例，每次各取一个 Uint64，可以用等值比较观察它们是否保持同步。

package main

import (
    "fmt"
    "math/rand/v2"
)

func main() {
    // 两个实例共享同一份固定输入，但内部状态彼此独立。
    seed := [32]byte{1, 3, 5, 7, 9, 11}
    left := rand.NewChaCha8(seed)
    right := rand.NewChaCha8(seed)

    for i := 0; i 

如果其中一个实例先调用了一次 Uint64，再进入循环，它就会领先一个位置，后面的比较自然会失败。这不是随机数“失效”，而是生成器状态已经被推进。

需要 IntN 等方法时用 rand.New 包装

ChaCha8 实现了 Source，最直接的方法是 Uint64。若测试需要限定范围、打乱切片或生成浮点数，可以把它交给 rand.New，得到绑定到同一状态的 *rand.Rand。

package main

import (
    "fmt"
    "math/rand/v2"
)

func main() {
    // 固定种子保证模拟订单的选择顺序能够回放。
    seed := [32]byte{2, 4, 6, 8}
    source := rand.NewChaCha8(seed)
    r := rand.New(source)

    // IntN 的上界不包含在结果中；这里结果范围是 [0, 10)。
    bucket := r.IntN(10)
    fmt.Println(bucket)
}

不要一边直接调用 source.Uint64()，一边又通过 r.IntN 使用同一个底层状态来设计严格的回放协议。虽然两者都来自同一个源，但调用消耗的状态不同；更稳妥的做法是为一个回放场景固定一种调用层级。

Seed 可以把同一个实例恢复到起点

(*ChaCha8).Seed 会重置生成器，使它表现得像用同一种子重新调用 NewChaCha8。这适合表驱动测试：同一个对象先跑一段，再用相同种子恢复，然后重复检查关键结果。

package main

import (
    "fmt"
    "math/rand/v2"
)

func main() {
    // 固定种子用于测试回放，不把它当成秘密材料。
    seed := [32]byte{10, 20, 30, 40}
    source := rand.NewChaCha8(seed)

    first := source.Uint64()
    _ = source.Uint64() // 先推进一次状态，模拟被测逻辑已经取过随机数。

    // 重置后，下一次输出应回到同一初始序列的第一个位置。
    source.Seed(seed)
    replay := source.Uint64()
    fmt.Println(first == replay)
}

如果被测逻辑中间新增了一次随机调用，后续序列会整体错位。因此回放测试除了保存种子，还应该明确每个阶段允许消耗几次随机值，不要只比较最后一个结果。

Read 适合字节流，但不要依赖混合调用的细节

当前 math/rand/v2.ChaCha8 也提供 Read，它会把随机字节写入目标切片，并返回完整长度和空错误。这个方法适合测试数据、模拟负载或固定格式的随机字节，不适合生成需要保密的密钥。

package main

import (
    "fmt"
    "math/rand/v2"
)

func main() {
    // 固定种子让测试字节在每次回放中保持一致。
    seed := [32]byte{42}
    source := rand.NewChaCha8(seed)
    data := make([]byte, 12)

    // Read 按目标切片长度填充；这里检查返回值用于表达调用契约。
    n, err := source.Read(data)
    if err != nil {
        panic(err)
    }
    fmt.Println(n == len(data))
}

官方文档特别提醒：如果把 Read 和 Uint64 交错调用，返回位的顺序没有定义，Read 甚至可能取到上一次 Uint64 之前生成的位。需要稳定回放时，建议一个阶段只使用一种读取方式，或者把调用协议写进测试辅助函数。

固定种子不等于安全随机数

ChaCha8 的算法本身具有较强的随机性，但只要种子固定且被别人知道，序列就是可预测的。测试、蒙特卡洛模拟、负载回放、随机排序的可重复样本都适合使用它；登录令牌、密码重置链接、会话标识、密钥和抽奖等不可预测场景，不要用固定种子的 math/rand/v2。

package main

import (
    crand "crypto/rand"
    "fmt"
)

func main() {
    secret := make([]byte, 32)
    // 秘密材料使用操作系统提供的密码学随机源，不使用固定种子回放。
    if _, err := crand.Read(secret); err != nil {
        panic(err)
    }
    fmt.Println(len(secret))
}

判断标准很简单：如果“下一次结果能否被复现”是需求，用独立的 ChaCha8 和固定种子；如果“别人不能猜到下一次结果”是需求，就把随机源切换到 crypto/rand，并避免记录或复用秘密种子。

一张表区分常见写法

常见问题

为什么不能像旧版 math/rand 那样传 int64？ ChaCha8 的 API 设计使用固定的 [32]byte 种子，不兼容旧版的单个整数种子；迁移时应明确构造新的种子。

相同种子为什么结果还是不一样？ 先检查是否调用了全局函数、是否有实例在循环外多取了一次、是否改变了 IntN 与 Uint64 的调用顺序。

ChaCha8 能不能直接替代 crypto/rand？ 固定种子场景不能。即使算法具有较强的随机性，只要种子或状态可推断，输出就不适合作为秘密材料。

测试中应该保存完整随机序列吗？ 通常保存种子、调用协议和关键断言即可；只有在兼容性回放确实要求时，才把完整序列作为独立 fixture。

总结一下：用 rand.NewChaCha8([32]byte) 建立独立状态，用相同种子和相同调用顺序获得可复现序列，用 Seed 重置回放；一旦需求变成不可预测，就切换到 crypto/rand，不要把“可复现”误当成“安全”。