解決Go中使用seed得到相同隨機數的問題
1. 重複的隨機數
廢話不多說，首先我們來看使用seed的一個很神奇的現象。
func main() {
for i := 0; i < 5; i++ {
rand.Seed(time.Now().Unix())
fmt.Println(rand.Intn(100))
}
}
// 結果如下
// 90
// 90
// 90
// 90
// 90
可能不熟悉seed用法的看到這裡會很疑惑，我不是都用了seed嗎？為何我隨機出來的數字都是一樣的？不應該每次都不一樣嗎？
可能會有人說是你資料的樣本空間太小了，OK，我們加大樣本空間到10w再試試。
func main() {
for i := 0; i < 5; i++ {
rand.Seed(time.Now().Unix())
fmt.Println(rand.Intn(100000))
}
}
// 結果如下
// 84077
// 84077
// 84077
// 84077
// 84077你會發現結果仍然是一樣的。簡單的推理一下我們就能知道，在上面那種情況，每次都取到相同的隨機數跟我們所取的樣本空間大小是無關的。那麼唯一有關的就是seed。我們首先得明確seed的用途。
2. seed的用途
在這裡就不賣關子了，先給出結論。
上面每次得到相同隨機數是因為在上面的迴圈中，每次操作的間隔都在毫秒級下，所以每次通過time.Now().Unix()取出來的時間戳都是同一個值，換句話說就是使用了同一個seed。
這個其實很好驗證。只需要在每次迴圈的時候將生成的時間戳打印出來，你就會發現每次打印出來的時間戳都是一樣的。
每次rand都會使用相同的seed來生成隨機佇列，這樣一來在迴圈中使用相同seed得到的隨機佇列都是相同的，而生成隨機數時每次都會去取同一個位置的數，所以每次取到的隨機數都是相同的。
seed 只用於決定一個確定的隨機序列。不管seed多大多小，只要隨機序列一確定，本身就不會再重複。除非是樣本空間太小。解決方案有兩種：
在全域性初始化呼叫一次seed即可
每次使用納秒級別的種子（強烈不推薦這種）
3. 不用每次呼叫
上面的解決方案建議各位不要使用第二種，給出是因為在某種情況下的確可以解決問題。比如在你的服務中使用這個seed的地方是序列的，那麼每次得到的隨機序列的確會不一樣。
但是如果在高併發下呢？你能夠保證每次取到的還是不一樣的嗎？事實證明，在高併發下，即使使用UnixNano作為解決方案，同樣會得到相同的時間戳，Go官方也不建議在服務中同時呼叫。
Seed should not be called concurrently with any other Rand method.
接下來會帶大家瞭解一下程式碼的細節。想了解原始碼的可以繼續讀下去。
4. 原始碼解析-seed
4.1 seed
首先來看一下seed做了什麼。
func (rng *rngSource) Seed(seed int64) {
rng.tap = 0
rng.feed = rngLen - rngTap
seed = seed % int32max
if seed < 0 { // 如果是負數，則強行轉換為一個int32的整數
seed += int32max
}
if seed == 0 { // 如果seed沒有被賦值，則預設給一個值
seed = 89482311
}
x := int32(seed)
for i := -20; i < rngLen; i++ {
x = seedrand(x)
if i >= 0 {
var u int64
u = int64(x) << 40
x = seedrand(x)
u ^= int64(x) << 20
x = seedrand(x)
u ^= int64(x)
u ^= rngCooked[i]
rng.vec[i] = u
}
}
}
首先，seed賦值了兩個定義好的變數，rng.tap和rng.feed。rngLen和rngTap是兩個常量。我們來看一下相關的常量定義。
const ( rngLen = 607 rngTap = 273 rngMax = 1 << 63 rngMask = rngMax - 1 int32max = (1 << 31) - 1 )
由此可見，無論seed是否相同，這兩個變數的值都不會受seed的影響。同時，seed的值會最終決定x的值，只要seed相同，則得到的x就相同。而且無論seed是否被賦值，只要檢測到是零值，都會預設的賦值為89482311。
接下來我們再看seedrand。
4.2 seedrand
// seed rng x[n+1] = 48271 * x[n] mod (2**31 - 1)
func seedrand(x int32) int32 {
const (
A = 48271
Q = 44488
R = 3399
)
hi := x / Q // 取除數
lo := x % Q // 取餘數
x = A*lo - R*hi // 通過公式重新給x賦值
if x < 0 {
x += int32max // 如果x是負數，則強行轉換為一個int32的正整數
}
return x
}
可以看出，只要傳入的x相同，則最後輸出的x一定相同。進而最後得到的隨機序列rng.vec就相同。
到此我們驗證我們最開始給出的結論，即只要每次傳入的seed相同，則生成的隨機序列就相同。驗證了這個之後我們再繼續驗證為什麼每次取到的隨機序列的值都是相同的。
5. 原始碼解析-Intn
首先舉個例子，來直觀的描述上面提到的問題。
func printRandom() {
for i := 0; i < 2; i++ {
fmt.Println(rand.Intn(100))
}
}
// 結果
// 81
// 87
// 81
// 87
假設printRandom是一個單獨的Go檔案，那麼你無論run多少次，每次打印出來的隨機序列都是一樣的。通過閱讀seed的原始碼我們知道，這是因為生成了相同的隨機序列。那麼為什麼會每次都取到同樣的值呢？不說廢話，我們一層一層來看。
5.1 Intn
func (r *Rand) Intn(n int) int {
if n <= 0 {
panic("invalid argument to Intn")
}
if n <= 1<<31-1 {
return int(r.Int31n(int32(n)))
}
return int(r.Int63n(int64(n)))
}
可以看到，如果n小於等於0，就會直接panic。其次，會根據傳入的資料型別，返回對應的型別。
雖然說這裡呼叫分成了Int31n和Int63n，但是往下看的你會發現，其實都是呼叫的r.Int63()，只不過在返回64位的時候做了一個右移的操作。
// r.Int31n的呼叫
func (r *Rand) Int31() int32 { return int32(r.Int63() >> 32) }
// r.Int63n的呼叫
func (r *Rand) Int63() int64 { return r.src.Int63() }
5.2 Int63
先給出這個函式的相關程式碼。
// 返回一個非負的int64偽隨機數.
func (rng *rngSource) Int63() int64 {
return int64(rng.Uint64() & rngMask)
}
func (rng *rngSource) Uint64() uint64 {
rng.tap--
if rng.tap < 0 {
rng.tap += rngLen
}
rng.feed--
if rng.feed < 0 {
rng.feed += rngLen
}
x := rng.vec[rng.feed] + rng.vec[rng.tap]
rng.vec[rng.feed] = x
return uint64(x)
}
可以看到，無論是int31還是int63，最終都會進入Uint64這個函式中。而在這兩個函式中，這兩個變數的值顯得尤為關鍵。因為直接決定了最後得到的隨機數，這兩個變數的賦值如下。
rng.tap = 0 rng.feed = rngLen - rngTap
tap的值是常量0，而feed的值決定於rngLen和rngTap，而這兩個變數的值也是一個常量。如此，每次從隨機佇列中取到的值都是確定的兩個值的和。
到這，我們也驗證了只要傳入的seed相同，並且每次都呼叫seed方法，那麼每次隨機出來的值一定是相同的。
6. 結論
首先評估是否需要使用seed，其次，使用seed只需要在全域性呼叫一次即可，如果多次呼叫則有可能取到相同隨機數。
總結
以上所述是小編給大家介紹的解決Go中使用seed得到相同隨機數的問題,希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回覆大家的。在此也非常感謝大家對我們網站的支援！
如果你覺得本文對你有幫助，歡迎轉載，煩請註明出處，謝謝！