Golang rand库随机数生成技巧

math/rand使用伪随机数生成器（PRNG），通过种子初始化生成可预测序列，需用time.Now().UnixNano()播种以确保每次运行序列不同；其核心是基于确定性算法（如线性同余或梅森旋转）生成随机数，适用于非安全场景如游戏、模拟；常见问题包括未播种导致序列重复、并发竞争和安全误用；规避方法为程序启动时播种、创建独立Rand实例避免竞争，且在安全敏感场景应使用crypto/rand替代，因后者提供密码学安全的随机数。

math/rand是Golang标准库中用于生成伪随机数的包。它提供了一套简单易用的API，可以生成各种类型的随机数，从整数到浮点数，在模拟、游戏逻辑或非安全敏感的场景中非常实用。但要记住，它生成的是“伪”随机数，这意味着其序列是可预测的，并且在默认情况下，如果不正确初始化种子，每次程序运行时都会得到相同的序列。

解决方案

在使用math/rand生成随机数时，最核心的步骤就是初始化随机数生成器的种子。这是因为math/rand是一个伪随机数生成器（PRNG），它依赖一个初始值（种子）来启动其生成序列。如果每次都用相同的种子，那么生成的随机数序列也会一模一样。

通常，我们会使用当前时间作为种子，以确保每次程序运行时都能得到不同的随机数序列。

package main

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

func main() {
    // 1. 初始化随机数生成器的种子
    // 推荐使用time.Now().UnixNano()，它提供了纳秒级别的时间戳，确保种子足够随机
    rand.Seed(time.Now().UnixNano())

    // 2. 生成各种类型的随机数
    fmt.Println("随机整数 (0 到 99):", rand.Intn(100)) // 生成 [0, 100) 范围的整数
    fmt.Println("随机浮点数 (0.0 到 1.0):", rand.Float64()) // 生成 [0.0, 1.0) 范围的浮点数
    fmt.Println("另一个随机整数:", rand.Int()) // 生成一个非负的随机整数

    // 3. 生成指定范围内的随机整数
    min := 10
    max := 20
    // 公式：min + rand.Intn(max - min + 1)
    fmt.Printf("指定范围 [%d, %d] 的随机整数: %d\n", min, max, min+rand.Intn(max-min+1))

    // 4. 如果需要多个独立的随机数生成器，可以创建新的Source和Rand实例
    // 避免多个goroutine共享全局rand导致竞争或可预测性问题
    s2 := rand.NewSource(time.Now().UnixNano() + 1) // 稍微不同的种子
    r2 := rand.New(s2)
    fmt.Println("使用独立生成器生成的随机整数:", r2.Intn(100))
}

这段代码展示了math/rand的基本用法，从种子初始化到生成不同类型的随机数，甚至提到了如何创建独立的随机数生成器。核心在于rand.Seed()这一步，它决定了你的随机数序列是否真的“随机”。

Golang中math/rand的随机数生成机制是怎样的？

要理解math/rand的工作方式，我们得从“伪随机数生成器”（PRNG）这个概念说起。说实话，我个人觉得“伪随机”这个词挺贴切的，它不是真正的随机，而是一种算法模拟出来的随机。math/rand库就是基于这样的算法实现的。

它的核心机制其实是：你给它一个起始值，也就是我们常说的“种子”（seed），然后它就会根据这个种子，通过一个确定性的数学公式，计算出下一个“随机数”。这个过程会不断重复，每次计算都以上一个生成的数为基础，或者说，以内部维护的状态为基础，来生成下一个数。所以，如果你每次都给它相同的种子，那么它就会一遍又一遍地吐出完全相同的随机数序列。这也就是为什么我们强调要用time.Now().UnixNano()来做种子的原因，因为它能提供一个相对独特且不断变化的起始点。

math/rand在内部维护了一个状态，这个状态会随着每次调用Int(), Float64()等方法而更新。默认情况下，Go程序启动时，math/rand会有一个全局的、未初始化的随机数源。如果你不调用rand.Seed()，它就会使用一个固定的默认种子（通常是1），这就会导致你每次运行程序都看到一样的随机数序列，这在开发和测试时可能很方便，但在实际应用中就成了个“坑”。

值得一提的是，math/rand的实现通常会选择一些性能较好、周期较长的算法，比如线性同余法（LCR）的变体，或者更复杂的梅森旋转算法（Mersenne Twister）。这些算法能够生成看起来很随机，并且统计特性良好的序列，足以满足大部分非安全敏感的场景。不过，它的设计目标是速度和易用性，而不是加密安全性。

math/rand在实际应用中常见的“坑”有哪些？如何规避？

我在实际开发中，经常会遇到开发者在使用math/rand时踩到一些小“坑”，这里我总结几个最常见的，并说说我的规避经验。

一个常见的误解是，不初始化种子就能得到随机数。我见过不少新手代码，直接rand.Intn(100)就用了，结果每次运行都得到同一个数字。这其实是最大的“坑”：未播种的随机数生成器。

• 问题表现：每次程序启动，随机数序列都一模一样。
• 规避方法：务必在程序入口处（通常是main函数开头）调用rand.Seed(time.Now().UnixNano())。这能确保每次运行都有一个不同的起始点。如果你的程序是长期运行的服务，只需要播种一次即可。

另一个我经常提醒的，是关于math/rand的非加密安全性。

• 问题表现：开发者可能在需要高安全性的地方（比如生成用户密码、会话令牌、加密密钥）错误地使用了math/rand。它的序列是可预测的，如果攻击者知道种子或能观察到足够多的输出，就有可能预测出后续的“随机”数。
• 规避方法：对于任何涉及安全敏感的场景，请务必使用crypto/rand包。crypto/rand从操作系统获取熵源，提供的是真正意义上的密码学安全随机数，虽然速度会慢一些，但安全性是其首要考量。

并发场景下，全局随机数生成器的竞争问题也是个隐患。

• 问题表现：当多个goroutine同时调用math/rand包中的全局函数（如rand.Intn()）时，可能会出现竞态条件，导致随机数生成器的内部状态被破坏，或者生成出不那么随机甚至可预测的序列。虽然Go的math/rand内部对全局源有锁保护，但频繁的锁竞争会影响性能，并且在某些特定场景下，多个goroutine快速连续请求随机数，可能会因为时间戳过于接近而使用相同的种子（如果每次都用time.Now().UnixNano()播种），导致序列的重复性问题。
• 规避方法：如果你的应用需要多个独立的随机数流，或者在并发环境下使用，我强烈建议你*创建独立的`rand.Rand`实例**。

  source := rand.NewSource(time.Now().UnixNano())
  r := rand.New(source) // r是一个独立的随机数生成器实例
  // 之后在goroutine中使用 r.Intn() 等方法

  这样每个goroutine或者每个需要独立随机数的地方都拥有自己的生成器，避免了全局锁的竞争和状态混淆。

最后，生成特定范围随机数时的边界问题也时常出现。

• 问题表现：想生成[min, max]范围的整数，但经常写成rand.Intn(max - min)或rand.Intn(max)，导致范围错误或包含/不包含边界值。
• 规避方法：记住公式min + rand.Intn(max - min + 1)。这能确保生成的随机数x满足min <= x <= max。

什么时候应该选择crypto/rand而不是math/rand？

这是一个非常关键的问题，也是我发现很多开发者容易混淆的地方。简单来说，选择哪个库，完全取决于你对随机数“质量”和“安全性”的需求。

当你需要的是非安全敏感、性能优先的随机数时，math/rand是你的首选。

• 应用场景：
  • 游戏逻辑：比如怪物刷新位置、掉落物品、卡牌洗牌（非赌博性质）。
  • 模拟和测试：生成模拟数据、性能测试中的随机输入。
  • 非关键性ID生成：生成一些不需要加密安全但需要唯一性的ID（但要注意碰撞概率）。
  • 随机排序或选择：从列表中随机抽取元素。
• 特点：
  • 速度快：因为它是一个纯软件算法，不依赖外部熵源。
  • 可预测：给定相同的种子，总是生成相同的序列，这在调试和重现问题时很有用。
  • 非加密安全：不适用于需要抵抗攻击的场景。

而当你对随机数的安全性有极高要求，需要抵抗预测和攻击时，crypto/rand是唯一正确的选择。

• 应用场景：
  • 生成加密密钥：无论是对称密钥还是非对称密钥，都必须使用crypto/rand。
  • 生成密码、安全令牌或会话ID：任何需要防止被猜测、暴力破解或重放攻击的字符串。
  • SSL/TLS证书的随机数部分。
  • 盐值（Salt）：在密码哈希中使用，增加破解难度。
  • 任何需要高熵值和不可预测性的场景。
• 特点：
  • 密码学安全：它从操作系统底层的熵池（如/dev/urandom或Windows的CryptGenRandom）获取随机数，这些熵源是硬件事件、系统噪声等难以预测的物理过程。
  • 不可预测：即使攻击者知道之前的输出，也无法预测后续的随机数。
  • 速度相对慢：因为它依赖于操作系统的熵源，获取随机数通常会比纯软件算法慢。
  • 不需要播种：crypto/rand是自播种的，你不需要手动调用Seed方法。

这里是一个使用crypto/rand生成安全随机字节的例子：

package main

import (
    "crypto/rand"
    "encoding/base64"
    "fmt"
    "log"
)

func main() {
    // 生成一个32字节的随机序列，适合作为加密密钥或安全令牌
    randomBytes := make([]byte, 32)
    _, err := rand.Read(randomBytes) // rand.Read直接从操作系统熵源读取
    if err != nil {
        log.Fatal("无法生成随机字节:", err)
    }

    // 将字节序列编码为Base64字符串，方便存储或传输
    secureToken := base64.URLEncoding.EncodeToString(randomBytes)
    fmt.Println("生成的安全令牌:", secureToken)
}

这段代码展示了crypto/rand的简洁性，你不需要关心播种，只需调用rand.Read()即可获得安全的随机字节。所以，在做技术选型时，一定要问自己：这个随机数是用来干什么的？它需要抵抗攻击吗？如果答案是肯定的，那就毫不犹豫地选择crypto/rand。