go - Go 库代码应该如何初始化和使用随机数生成？

Question

在编写需要使用随机数的 Go 库 时，初始化和使用随机数的最佳方式是什么？

我知道在应用程序中执行此操作的标准方法是:

import (
    "math/rand"
    "time"
)

// do the initial seeding in an init fn
func init() {
    // set the global seed and use the global fns
    rand.Seed(time.Now().UTC().UnixNano())
}

func main() {
    fmt.Println(rand.Int())
    fmt.Println(rand.Intn(200))
}

所以当我编写库代码时(不在主包中)，我是否应该这样做:

package libfoo

func init() {
    rand.Seed(time.Now().UTC().UnixNano())
}

func AwesomeFoo() {
    r :=  rand.Intn(1000)
    // ...
}

使用我的库的应用程序也可能会做自己的随机数播种并使用 rand.Intn，所以我的问题真的是 - 让库播种随机数生成器和一些应用程序代码(或其他库)也这样做吗？

使用“全局”rand.Intn 或 rand.Int 的库是否也存在任何问题，或者库是否应该创建自己的私有(private) Rand object via rand.New(src) 并改用它？

我没有任何特别的理由认为这是不安全的，但我对加密和 PRNG 有足够的了解，知道如果你不知道自己在做什么，很容易出错。

例如，这是一个需要随机性的 Knuth (Fisher-Yates) 洗牌的简单库:https://gist.github.com/quux00/8258425

Answer 1

什么是最好的实际上只取决于您正在编写的应用程序类型和您要创建的库类型。如果我们不确定，我们可以通过 Go 接口(interface)使用一种依赖注入(inject)形式来获得最大的灵 active 。

考虑以下利用 rand.Source 接口(interface)的朴素蒙特卡罗积分器:

package monte

import (
    "math/rand"
)

const (
    DEFAULT_STEPS = 100000
)

type Naive struct {
    rand *rand.Rand
    steps int
}

func NewNaive(source rand.Source) *Naive {
    return &Naive{rand.New(source), DEFAULT_STEPS}
}

func (m *Naive) SetSteps(steps int) {
    m.steps = steps
}

func (m *Naive) Integrate1D(fn func(float64) float64, a, b float64) float64 {
    var sum float64
    for i := 0; i < m.steps; i++ {
        x := (b-a) * m.rand.Float64() 
        sum += fn(x)
    }
    return (b-a)*sum/float64(m.steps)
}

然后我们可以使用这个包来计算 pi 的值:

func main() {
    m := monte.NewNaive(rand.NewSource(200))
    pi := 4*m.Integrate1D(func (t float64) float64 {
        return math.Sqrt(1-t*t)
    }, 0, 1)
    fmt.Println(pi)
}

在这种情况下，我们算法结果的质量取决于所使用的伪随机数生成器的类型，因此我们需要为用户提供一种将一个生成器替换为另一个生成器的方法。这里我们定义了一个不透明类型，它在其构造函数中采用随机数源。通过让他们的随机数生成器满足 rand.Source 接口(interface)，我们的应用程序编写者可以根据需要更换随机数生成器。

但是，在很多情况下，这正是我们不想做的。考虑一个随 secret 码或 key 生成器。在那种情况下，我们真正想要的是真正随机数据的高熵源，所以我们应该只在内部使用 crypto/rand 包并向我们的应用程序编写者隐藏细节:

package keygen

import (
    "crypto/rand"
    "encoding/base32"
)

func GenKey() (string, error) {
    b := make([]byte, 20)
    if _, err := rand.Read(b); err != nil {
        return "", err
    }
    enc := base32.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZ346789")
    return enc.EncodeToString(b), nil
}

希望这能帮助您做出决定。如果代码用于您自己的应用程序或特定公司内的应用程序而不是行业范围或公共(public)用途，则倾向于公开最少内部结构并创建最少依赖项的库设计而不是最通用的设计，因为这将简化维护和缩短实现时间。

基本上，如果感觉有点矫枉过正，那可能就是这样。

在 Knuth Shuffle 的情况下，要求只是一个像样的伪随机数生成器，因此您可以简单地使用一个内部种子 rand.Rand 对象，它对您的包是私有(private)的，如下所示:

package shuffle

import (
    "math/rand"
    "time"
)

var r *rand.Rand

func init() {
    r = rand.New(rand.NewSource(time.Now().UTC().UnixNano()))
}

func ShuffleStrings(arr []string) {
    last := len(arr)-1
    for i := range arr {
        j := r.Intn(last)
        arr[i], arr[j] = arr[j], arr[i]
    }
}

那么应用程序就不必担心它是如何工作的:

package main

import (
    "shuffle"
    "fmt"
)

func main() {
    arr := []string{"a","set","of","words"}
    fmt.Printf("Shuffling words: %v\n", arr)
    for i := 0; i<10; i++ {
        shuffle.ShuffleStrings(arr)
        fmt.Printf("Shuffled words: %v\n", arr)
    }
}

这可以防止应用程序通过调用 rand.Seed 意外地为您的包使用的随机数生成器重新设定种子。