Go 库中随机数生成的策略与最佳实践

package monte

import (
    "math"
    "math/rand"
)

const (
    DEFAULT_STEPS = 100000 // 默认积分步数
)

// Naive 是一个简单的 Monte Carlo 积分器
type Naive struct {
    randSource *rand.Rand // 内部使用私有的 rand.Rand 实例
    steps      int        // 积分步数
}

// NewNaive 创建一个新的 Naive 积分器实例。
// 它接受一个 rand.Source 接口作为参数，允许调用者提供自定义的随机源。
func NewNaive(source rand.Source) *Naive {
    return &Naive{rand.New(source), DEFAULT_STEPS}
}

// SetSteps 设置积分步数
func (m *Naive) SetSteps(steps int) {
    m.steps = steps
}

// Integrate1D 对一维函数进行积分
func (m *Naive) Integrate1D(fn func(float64) float64, a, b float64) float64 {
    var sum float64
    for i := 0; i < m.steps; i++ {
        // 使用内部的随机数生成器实例
        x := a + (b-a)*m.randSource.Float64() 
        sum += fn(x)
    }
    return (b - a) * sum / float64(m.steps)
}

package main

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

    "yourmodule/monte" // 假设 monte 包在你的模块中
)

func main() {
    // 使用固定种子，以便结果可重复
    mFixed := monte.NewNaive(rand.NewSource(200))
    piFixed := 4 * mFixed.Integrate1D(func(t float64) float64 {
        return math.Sqrt(1 - t*t)
    }, 0, 1)
    fmt.Printf("使用固定种子计算 Pi: %f\n", piFixed)

    // 使用当前时间作为种子，每次运行结果不同
    mTime := monte.NewNaive(rand.NewSource(time.Now().UTC().UnixNano()))
    piTime := 4 * mTime.Integrate1D(func(t float64) float64 {
        return math.Sqrt(1 - t*t)
    }, 0, 1)
    fmt.Printf("使用时间种子计算 Pi: %f\n", piTime)
}

package keygen

import (
    "crypto/rand"
    "encoding/base32"
    "fmt" // 仅用于错误信息，实际生产代码可能使用更专业的日志库
)

// GenKey 生成一个加密安全的随机密钥字符串。
// 密钥长度为20字节，并使用 Base32 进行编码。
func GenKey() (string, error) {
    b := make([]byte, 20) // 生成20字节的随机数据
    if _, err := rand.Read(b); err != nil {
        return "", fmt.Errorf("无法读取加密随机源: %w", err)
    }

    // 使用自定义的 Base32 编码字符集，避免混淆字符（如 I/1, O/0）
    enc := base32.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567") 
    return enc.EncodeToString(b), nil
}

package main

import (
    "fmt"
    "yourmodule/keygen" // 假设 keygen 包在你的模块中
)

func main() {
    key, err := keygen.GenKey()
    if err != nil {
        fmt.Printf("生成密钥失败: %v\n", err)
        return
    }
    fmt.Printf("生成的安全密钥: %s\n", key)
}

package shuffle

import (
    "math/rand"
    "time"
)

// r 是包内部私有的 rand.Rand 实例
var r *rand.Rand

// init 函数在包被导入时自动执行，用于初始化私有随机数生成器。
// 这样可以确保每个程序运行时的随机序列不同，但库内部的随机性是隔离的。
func init() {
    r = rand.New(rand.NewSource(time.Now().UTC().UnixNano()))
}

// ShuffleStrings 对字符串切片进行随机洗牌。
func ShuffleStrings(arr []string) {
    last := len(arr) - 1
    for i := range arr {
        // 生成一个 [0, last] 范围内的随机索引 j
        // 注意：这里使用 Intn(last+1) 而不是 Intn(last)
        // 因为原始问题中的 Knuth Shuffle 示例有误，
        // 正确的 Fisher-Yates 算法是从当前元素到数组末尾选择一个随机元素进行交换。
        // 这里为了匹配原答案的意图，即在一个固定范围内随机交换，
        // 仍使用 Intn(last) 但需要确保其行为符合预期。
        // 实际上，更标准的 Fisher-Yates 是 `j := i + r.Intn(len(arr)-i)`。
        // 为了遵循原答案的简化，我们假设 `j` 是在 `[0, last]` 范围内。
        // 修正为标准的 Fisher-Yates 算法：
        j := r.Intn(i + 1) // 随机选择一个索引 j，范围在 [0, i]
        arr[i], arr[j] = arr[j], arr[i]
    }
    // 原始问题中的 Knuth Shuffle 示例：
    // for i := range arr {
    //     j := r.Intn(last) // 这是一个简化的/可能不完全正确的 Fisher-Yates 实现
    //     arr[i], arr[j] = arr[j], arr[i]
    // }
    // 为了提供一个更可靠的洗牌，我们使用标准的 Fisher-Yates：
    // for i := len(arr) - 1; i > 0; i-- {
    //     j := r.Intn(i + 1) // 随机选择一个索引 j，范围在 [0, i]
    //     arr[i], arr[j] = arr[j], arr[i]
    // }
}

package main

import (
    "fmt"
    "yourmodule/shuffle" // 假设 shuffle 包在你的模块中
)

func main() {
    arr := []string{"a", "set", "of", "words"}
    fmt.Printf("初始单词列表: %v\n", arr)

    for i := 0; i < 3; i++ {
        // 每次调用 ShuffleStrings 都会使用 shuffle 包内部独立的随机数生成器
        shuffle.ShuffleStrings(arr)
        fmt.Printf("第 %d 次洗牌后: %v\n", i+1, arr)
    }

    // 应用程序可以自由使用全局的 rand.Seed 或其他随机数，不会影响 shuffle 包
    rand.Seed(123)
    fmt.Println("应用程序全局随机数:", rand.Intn(100))
}