1. 从“随机”到“可控”为什么区间随机数是个技术活在编程世界里“随机”是一个既迷人又充满陷阱的概念。尤其在GolangGo语言里处理随机数生成特别是生成指定区间内的随机数远不止是调用一个rand.Intn()那么简单。很多刚接触Go的开发者甚至一些有经验的程序员都曾在这里踩过坑生成的随机数序列总是重复、性能瓶颈、甚至在高并发场景下出现数据竞争导致程序崩溃。我见过不少项目在需要生成验证码、分配随机任务、模拟测试数据时直接上手就写结果上线后要么是随机性不够“随机”要么是性能跟不上。问题的核心往往在于大家只记住了“怎么生成”却忽略了“为什么这样生成”以及“在什么场景下该怎样生成”。生成一个[0, 100)的随机数和生成一个[-50, 50)或者[1.5, 3.8)的浮点数随机数背后的数学转换和库函数选择是完全不同的。今天我们就抛开那些浅尝辄止的教程深入Golang的math/rand和crypto/rand包把“生成指定区间随机数”这件事掰开揉碎了讲清楚。我会带你从最基础的伪随机数生成器PRNG原理讲起一步步拆解整数区间、浮点数区间的转换公式分析math/rand与crypto/rand的核心差异与选型依据并深入到高并发、高性能场景下的最佳实践和那些官方文档里不会写的“坑”。无论你是正在学习Go的新手还是需要优化现有随机数逻辑的资深工程师这篇文章都能给你带来可直接落地的代码和清晰透彻的理解。2. 基石理解Golang中的两种随机数源在动手写代码之前我们必须先搞清楚Golang为我们提供了哪几种“随机性”。这是所有后续操作的基础选错了源你的程序可能在安全性、性能或随机性质量上出现根本性问题。2.1math/rand确定性伪随机数生成器math/rand是Go标准库中最常用的随机数包。但它的第一个重要特性常常被忽略它是确定性的伪随机数生成器。这意味着只要你使用相同的种子Seed进行初始化那么每次程序运行时rand.Intn()、rand.Float64()等函数生成的随机数序列将是完全相同的。package main import ( fmt math/rand ) func main() { // 使用固定种子 42 rand.Seed(42) fmt.Println(rand.Intn(100)) // 第一次运行输出 5 fmt.Println(rand.Intn(100)) // 输出 87 // 重置种子为 42序列会从头开始 rand.Seed(42) fmt.Println(rand.Intn(100)) // 再次输出 5 fmt.Println(rand.Intn(100)) // 再次输出 87 }这种确定性在需要可重现结果的场景下是优点比如单元测试、算法演示或科学模拟。你可以通过固定种子确保每次测试都基于相同的“随机”输入从而稳定测试结果。但在需要真正“不可预测”随机性的场景如生成会话令牌、加密密钥时这就是一个致命缺陷。math/rand默认的全局生成器还有一个更严重的问题它不是并发安全的。多个goroutine同时调用rand.Intn()会导致数据竞争data race虽然Go 1.20之后在某些情况下做了优化但依赖全局状态本身就是不推荐的模式。// 不安全的并发示例可能引发数据竞争 for i : 0; i 10; i { go func() { fmt.Println(rand.Intn(100)) // 多个goroutine并发访问全局rand }() }因此在现代Go编程中使用math/rand的正确姿势是为每个需要独立随机序列的模块或goroutine创建自己的rand.Rand实例。这通过rand.New(rand.NewSource(seed))来实现。import math/rand // 创建独立的随机数生成器 func NewRandomGenerator(seed int64) *rand.Rand { source : rand.NewSource(seed) // 创建源 return rand.New(source) // 创建生成器 } func main() { // 为不同任务创建独立的生成器 rng1 : NewRandomGenerator(123) rng2 : NewRandomGenerator(456) // 它们互不干扰且各自内部序列确定 fmt.Println(rng1.Intn(100)) // 基于种子123的序列 fmt.Println(rng2.Intn(100)) // 基于种子456的序列 }那么如何为这些独立的生成器设置一个“好”的种子使其在需要时尽可能不可预测呢传统做法是使用当前时间戳time.Now().UnixNano()但这在批量快速创建实例时可能不够分散。更推荐的做法是使用crypto/rand包来生成密码学安全的随机种子。2.2crypto/rand密码学安全的随机数当你的应用涉及安全敏感操作时math/rand就完全不够用了。crypto/rand包提供了密码学安全的随机数生成器它直接从操作系统获取熵如硬件噪声、中断时间等生成的随机数具有高度的不可预测性适用于生成加密密钥、令牌、盐值等。它的API与math/rand不同主要函数是Read(b []byte)用于向字节切片中填充随机字节。import ( crypto/rand encoding/binary fmt ) // 生成一个密码学安全的随机整数种子 func SecureSeed() (int64, error) { var seed int64 // 读取8个字节int64的大小的随机数据 err : binary.Read(rand.Reader, binary.BigEndian, seed) if err ! nil { return 0, err } return seed, nil } func main() { seed, err : SecureSeed() if err ! nil { panic(err) } // 用这个安全的种子初始化一个 math/rand 生成器 // 这样既获得了 crypto/rand 的安全性又能使用 math/rand 丰富的API rng : rand.New(rand.NewSource(seed)) fmt.Println(rng.Intn(100)) }注意直接使用crypto/rand生成大量随机数的性能开销远高于math/rand。因此一个常见的混合模式是用crypto/rand生成一个高质量的种子然后用这个种子初始化一个独立的math/rand.Rand实例供后续大量使用。这样在大多数需要“好随机”但非最高安全级别的场景下取得了安全与性能的平衡。2.3 核心选型决策树面对一个具体需求你该如何选择可以参考下面的决策流程是否需要密码学级别的安全性不可预测、防攻击是- 直接使用crypto/rand。场景生成JWT密钥、CSRF令牌、密码重置Token、加密盐值。否- 进入下一步。是否需要可重现的确定性结果如测试、模拟是- 使用math/rand并设置一个固定的种子如rand.Seed(42)。为隔离性建议创建独立的rand.Rand实例。否- 进入下一步。是否是高并发场景是-绝对不要使用全局的math/rand函数。必须为每个goroutine或逻辑单元创建独立的rand.Rand实例。种子可以使用time.Now().UnixNano()加上一些唯一标识或者更推荐用crypto/rand生成。否- 可以使用全局math/rand但最好在程序启动时用time.Now().UnixNano()初始化一次种子 (rand.Seed)以避免每次运行序列相同。不过创建独立实例仍然是更清晰、更可控的做法。简单来说math/rand用于一般随机性游戏、算法、测试crypto/rand用于安全随机性。在高并发下将math/rand实例化是铁律。3. 整数区间随机数公式推导与边界陷阱解决了随机数源的问题我们终于可以进入正题如何生成指定区间[min, max]内的随机整数。这里min和max都是整数且min max。3.1 通用公式的由来Golang的rand.Intn(n)函数返回一个范围在[0, n)的半开区间随机整数。我们的目标是将这个输出映射到我们想要的[min, max]闭区间。推导过程如下rand.Intn(k)生成[0, k)的随机数共有k种可能。我们希望的结果范围[min, max]包含的整数个数为max - min 1。记这个数为rangeSize。因此我们需要k rangeSize即rand.Intn(max - min 1)这样我们得到了[0, max-min]范围内的随机数。将这个结果加上min就完成了平移[0, max-min] min [min, max]。最终公式为result : rand.Intn(max - min 1) min// RandomInt 生成一个在闭区间 [min, max] 内的随机整数。 // 使用传入的 *rand.Rand 实例以支持并发安全。 func RandomInt(r *rand.Rand, min, max int) int { if min max { // 处理非法输入也可以panic根据业务逻辑决定 min, max max, min } // 核心公式 return r.Intn(max-min1) min } func main() { rng : rand.New(rand.NewSource(time.Now().UnixNano())) // 生成一个 [5, 15] 之间的随机整数 num : RandomInt(rng, 5, 15) fmt.Printf(随机数5到15之间: %d\n, num) }3.2 边界条件与常见“坑点”这个看似简单的公式在实际编码中却有几个必须警惕的边界情况坑点一整数溢出当min和max非常大或者min为负数时计算max - min 1可能导致整数溢出对于32位或64位整数。虽然Go中int是平台相关的通常64位但显式处理能增加代码健壮性。func RandomIntSafe(r *rand.Rand, min, max int) (int, error) { if min max { return 0, fmt.Errorf(min (%d) must be less than or equal to max (%d), min, max) } // 检查范围大小是否在 int 可表示范围内避免后续转换问题 rangeSize : int64(max) - int64(min) 1 if rangeSize 0 { // 当 min 和 max 非常接近 int 类型边界时rangeSize 可能溢出 int64实际上不会因为int64范围更大。 // 这里更应关注 rangeSize 是否超过了 rand.Intn 能处理的最大值rand.Intn 参数是 int其最大值是 int 最大值。 // 一个更实际的检查是rangeSize 是否超出了某个合理上限比如10亿 } // 注意rand.Intn 的参数必须是 int 类型且 0 if rangeSize int64(^uint(0)1) { // 粗略检查是否超过int最大值 return 0, fmt.Errorf(range size too large) } return r.Intn(int(rangeSize)) min, nil }坑点二rand.Intn(0)会导致panic根据公式如果min和max相等那么max - min 1 1rand.Intn(1)永远返回0加上min后结果正确。但是如果错误地传入了min max且未做校验可能导致max-min1为负数或零从而引发rand.Intn的panic因为其要求参数 n 0。这就是为什么在函数开头进行min和max大小判断或交换至关重要。坑点三误解区间类型务必清楚你需要的区间是开区间(min, max)、半开区间[min, max)还是闭区间[min, max]。上述公式是针对闭区间。如果需要半开区间[min, max)公式应改为rand.Intn(max - min) min。业务逻辑的微小差异会导致公式的不同写代码和审查代码时必须明确。4. 浮点数区间随机数精度与分布的秘密生成指定区间的随机浮点数听起来只是把整数公式中的Intn换成Float64但水要深得多。核心问题在于浮点数的精度限制和分布特性。4.1 标准均匀分布转换rand.Float64()返回一个在[0.0, 1.0)区间内注意是左闭右开均匀分布的float64随机数。要将它映射到任意区间[min, max]无论是整数还是浮点数作为边界公式是线性的result : rand.Float64()*(max-min) min这个公式会生成一个在[min, max)区间内均匀分布的随机浮点数。如果需要闭区间[min, max]理论上无法完美实现因为浮点数表示是离散的且rand.Float64()不包含1.0。但可以通过生成[min, nextAfter(max)]来近似或者对于精度要求不极高的场景可以忽略右端点的极小概率差异。// RandomFloat 生成一个在半开区间 [min, max) 内均匀分布的随机浮点数。 func RandomFloat(r *rand.Rand, min, max float64) float64 { if min max { min, max max, min } return r.Float64()*(max-min) min } // RandomFloatClosedApprox 近似生成闭区间 [min, max] 的随机浮点数。 // 通过生成一个 [0, 1] 的随机数来实现。注意由于浮点精度max被包含的概率极低。 func RandomFloatClosedApprox(r *rand.Rand, min, max float64) float64 { if min max { min, max max, min } // 使用 rand.Float64() 可能永远无法精确等于1.0所以这不是严格的闭区间。 // 一种方法是生成 [0, 1] 的整数随机数再转换但对于浮点数边界很复杂。 // 更实用的做法是如果业务逻辑可以接受使用 [min, max) 即可。 // 这里演示一种方法生成 [0, 1] 的随机数通过取两个随机数最大值等技巧逼近。 // 但对于大多数应用[min, max) 已经足够。 return min (max-min)*r.Float64() // 这实际上是 [min, max) }4.2 精度丢失与“模运算”陷阱一个严重的陷阱是不要试图通过生成大范围整数再除以缩放因子来得到浮点数。例如想生成[0, 1)之间保留两位小数的随机数有人可能会先生成[0, 99]的随机整数然后除以100.0。这看起来没问题但实际上你丢失了绝大部分的随机性结果只有100种可能而不是float64能表示的巨量可能值。// 错误做法随机性被严重限制 func BadRandomFloat() float64 { rng : rand.New(rand.NewSource(time.Now().UnixNano())) integerPart : rng.Intn(100) // 只有100种可能 (0-99) return float64(integerPart) / 100.0 // 结果只有0.00, 0.01, ..., 0.99 } // 正确做法直接利用 Float64 的完整精度 func GoodRandomFloat() float64 { rng : rand.New(rand.NewSource(time.Now().UnixNano())) return rng.Float64() // 有2^53种可能的有效值随机性丰富得多 }如果需要指定位数的随机小数应该在生成完整精度的随机浮点数之后再进行四舍五入而不是在生成过程中限制精度。4.3 非均匀分布生成有时我们需要的不是均匀分布而是其他分布比如正态分布高斯分布、指数分布等。math/rand包中的rand.NormFloat64()和rand.ExpFloat64()可以帮我们生成符合标准正态分布均值0标准差1和标准指数分布速率参数1的随机数。生成任意均值mu和标准差sigma的正态分布随机数的公式是result : rand.NormFloat64()*sigma mu// RandomNormal 生成一个服从正态分布 N(mu, sigma^2) 的随机数。 func RandomNormal(r *rand.Rand, mu, sigma float64) float64 { return r.NormFloat64()*sigma mu } func main() { rng : rand.New(rand.NewSource(42)) // 生成均值为100标准差为15的随机数模拟智商分数 iqScore : RandomNormal(rng, 100.0, 15.0) fmt.Printf(随机智商分数: %.2f\n, iqScore) }实操心得在模拟真实世界数据如用户身高、页面加载时间、股票收益率时正态分布非常有用。但要注意rand.NormFloat64()生成的数值理论上是无界的从负无穷到正无穷。在实际应用中可能需要根据业务逻辑对结果进行截断如身高不应为负数。5. 并发、性能与实战中的“高级玩法”当随机数生成从单线程demo走向高并发生产环境时一系列新的挑战会出现。5.1 高并发下的最佳实践全局的math/rand生成器是一颗并发炸弹。解决方案我们已经提过使用独立的rand.Rand实例。但如何高效地创建和管理这些实例呢方案一每个goroutine一个生成器在goroutine启动时为其创建一个独立的生成器种子可以基于goroutine ID和时间戳的混合。import ( math/rand sync time ) func worker(id int, wg *sync.WaitGroup) { defer wg.Done() // 为每个worker创建独立的随机源使用组合种子减少冲突 seed : time.Now().UnixNano() int64(id)*1000 rng : rand.New(rand.NewSource(seed)) for i : 0; i 5; i { fmt.Printf(Worker %d: %d\n, id, rng.Intn(100)) } } func main() { var wg sync.WaitGroup for i : 0; i 3; i { wg.Add(1) go worker(i, wg) } wg.Wait() }方案二使用线程局部存储TLS模拟Go没有直接的TLS但可以通过sync.Pool来池化随机数生成器或者使用一个全局的随机数生成器通道但要注意通道可能成为瓶颈。方案三分离“种子生成”与“随机数生成”在服务启动时用一个密码学安全的源crypto/rand批量生成一批高质量种子。然后每个goroutine或请求从这批种子中取用一个例如通过原子计数器索引来初始化自己的rand.Rand。这避免了在请求处理过程中频繁调用开销较大的crypto/rand。import ( crypto/rand encoding/binary math/rand sync/atomic ) var seedPool []int64 var seedIndex uint32 func init() { // 预生成1000个安全种子 const poolSize 1000 seedPool make([]int64, poolSize) for i : range seedPool { binary.Read(rand.Reader, binary.BigEndian, seedPool[i]) } } func GetThreadLocalRand() *rand.Rand { // 原子递增索引循环使用种子池 idx : atomic.AddUint32(seedIndex, 1) % uint32(len(seedPool)) seed : seedPool[idx] return rand.New(rand.NewSource(seed)) }5.2 性能考量与基准测试math/rand非常快但如果你在紧凑循环中每秒需要生成数百万个随机数它仍然可能成为热点。crypto/rand则要慢几个数量级。一个常见的性能优化是如果需要生成大量随机数且对安全性要求不是最高那么使用一个独立的、非全局的math/rand实例是最佳选择。避免在循环内部反复创建rand.Rand实例或调用rand.Seed。让我们用基准测试来直观感受一下// benchmark_test.go package main import ( crypto/rand math/rand testing ) // 全局生成器不安全仅对比性能 var globalRng rand.New(rand.NewSource(42)) func BenchmarkGlobalRandIntn(b *testing.B) { for i : 0; i b.N; i { _ rand.Intn(100) // 使用包级函数 } } func BenchmarkLocalRandIntn(b *testing.B) { rng : rand.New(rand.NewSource(42)) b.ResetTimer() for i : 0; i b.N; i { _ rng.Intn(100) } } func BenchmarkCryptoRandRead(b *testing.B) { buf : make([]byte, 8) // 生成一个int64 for i : 0; i b.N; i { _, _ rand.Read(buf) } }运行go test -bench. -benchmem你会看到类似下面的结果清晰展示了性能差异BenchmarkLocalRandIntn会比BenchmarkGlobalRandIntn稍快或持平且并发安全。BenchmarkCryptoRandRead会比前两者慢数百甚至上千倍。5.3 实战场景代码示例让我们看几个综合性的例子将上面的知识点串联起来。场景一生成随机字符串验证码、IDimport ( math/rand time ) const letterBytes abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 const ( letterIdxBits 6 // 6 bits to represent a letter index (0-63) letterIdxMask 1letterIdxBits - 1 // All 1-bits, as many as letterIdxBits ) // 高效生成随机字符串避免每次调用rand.Intn func RandStringBytesMask(rng *rand.Rand, n int) string { b : make([]byte, n) // A rng.Int63() generates 63 random bits, enough for letterIdxMask letters for i, cache, remain : n-1, rng.Int63(), letterIdxMask; i 0; { if remain 0 { cache, remain rng.Int63(), letterIdxMask } if idx : int(cache letterIdxMask); idx len(letterBytes) { b[i] letterBytes[idx] i-- } cache letterIdxBits remain-- } return string(b) } func main() { rng : rand.New(rand.NewSource(time.Now().UnixNano())) // 生成一个10位的随机字符串 randomStr : RandStringBytesMask(rng, 10) fmt.Println(随机字符串:, randomStr) }技巧这里使用了位运算来高效利用每次rand.Int63()调用产生的随机比特位避免了为每个字符都调用一次Intn在需要生成大量或长字符串时性能提升显著。场景二从切片中随机选择元素洗牌、抽样// RandomChoice 从切片中随机选择一个元素 func RandomChoice[T any](rng *rand.Rand, slice []T) (T, bool) { if len(slice) 0 { var zero T return zero, false } index : rng.Intn(len(slice)) return slice[index], true } // Shuffle 原地打乱切片Fisher-Yates洗牌算法 func Shuffle[T any](rng *rand.Rand, slice []T) { for i : len(slice) - 1; i 0; i-- { j : rng.Intn(i 1) slice[i], slice[j] slice[j], slice[i] } } func main() { rng : rand.New(rand.NewSource(time.Now().UnixNano())) users : []string{Alice, Bob, Charlie, Diana} // 随机选择一个 if user, ok : RandomChoice(rng, users); ok { fmt.Println(随机选中:, user) } // 打乱顺序 Shuffle(rng, users) fmt.Println(打乱后:, users) }场景三生成符合特定概率分布的随机事件// WeightedRandomChoice 根据权重随机选择索引 func WeightedRandomChoice(rng *rand.Rand, weights []float64) int { total : 0.0 for _, w : range weights { total w } if total 0 { return -1 } r : rng.Float64() * total sum : 0.0 for i, w : range weights { sum w if r sum { return i } } // 由于浮点数精度理论上不会走到这里但返回最后一个索引作为保护 return len(weights) - 1 } func main() { rng : rand.New(rand.NewSource(42)) // 物品掉落概率普通物品70%稀有物品25%史诗物品5% dropWeights : []float64{70.0, 25.0, 5.0} itemTypes : []string{普通, 稀有, 史诗} // 模拟10次掉落 for i : 0; i 10; i { choice : WeightedRandomChoice(rng, dropWeights) fmt.Printf(第%d次掉落: %s物品\n, i1, itemTypes[choice]) } }6. 测试、调试与常见问题排查即使理解了所有原理在实际项目中随机数相关的bug依然可能很隐蔽。如何测试和调试随机逻辑6.1 如何为随机逻辑编写可测试的单元测试随机性的本质使得测试变得困难因为你无法断言一个具体的输出值。测试策略需要转变测试确定性行为通过固定种子使随机序列可预测从而测试转换逻辑的正确性。func TestRandomIntWithFixedSeed(t *testing.T) { seed : int64(12345) rng : rand.New(rand.NewSource(seed)) // 因为种子固定rng.Intn(100)的序列是确定的 // 我们可以测试RandomInt函数是否正确应用了公式 got : RandomInt(rng, 10, 20) // 通过预先运行或计算我们知道当种子为12345时第一个rand.Intn(11)的结果假设是5 // 那么 RandomInt(rng, 10, 20) 应该返回 5 10 15 want : 15 // 这个值需要你根据固定种子和算法预先计算好 if got ! want { t.Errorf(RandomInt() with fixed seed %d, got %d, want %d, seed, got, want) } }测试统计属性运行多次测试结果的分布是否符合预期如平均值、范围、频率。func TestRandomIntDistribution(t *testing.T) { rng : rand.New(rand.NewSource(time.Now().UnixNano())) min, max : 1, 10 trials : 100000 counts : make([]int, max-min1) for i : 0; i trials; i { val : RandomInt(rng, min, max) if val min || val max { t.Fatalf(RandomInt() returned %d, out of range [%d, %d], val, min, max) } counts[val-min] } // 简单检查每个值出现的频率是否大致相等卡方检验简化版 expected : float64(trials) / float64(len(counts)) tolerance : 0.05 * expected // 允许5%的偏差 for val, count : range counts { if math.Abs(float64(count)-expected) tolerance { t.Errorf(Value %d appeared %d times, expected ~%.0f (outside tolerance), valmin, count, expected) } } }依赖注入将*rand.Rand作为参数传入业务函数而不是在函数内部创建。这样在测试中你可以传入一个模拟的、行为确定的生成器。// 生产代码 func GenerateOrderID(rng *rand.Rand, prefix string) string { randomNum : rng.Intn(10000) return fmt.Sprintf(%s-%04d, prefix, randomNum) } // 测试代码 func TestGenerateOrderID(t *testing.T) { mockRng : rand.New(rand.NewSource(999)) got : GenerateOrderID(mockRng, ORD) // 因为种子固定randomNum是确定的比如是1234 want : ORD-1234 if got ! want { t.Errorf(GenerateOrderID() %v, want %v, got, want) } }6.2 调试当随机行为不符合预期时问题“我的程序每次运行结果都一样”排查检查是否忘记初始化随机种子或者错误地使用了固定种子。确保在需要非确定性行为时使用了随时间变化的种子如time.Now().UnixNano()或密码学安全的随机源。问题“在高并发下我偶尔会得到重复的随机数或程序崩溃。”排查使用go run -race your_program.go检查数据竞争。确认你是否在多个goroutine中共享了同一个rand.Rand实例或使用了全局函数。改为使用goroutine局部的实例。问题“我生成的随机浮点数总是有很多重复的尾数。”排查你可能陷入了“模运算”陷阱即通过整数缩放来生成浮点数导致精度严重丢失。回顾第4.2节确保直接使用Float64()的完整精度。问题“crypto/rand读取太慢拖慢了整个API响应。”排查你是否在每次请求中都在调用crypto/rand.Read对于非最高安全要求的场景考虑使用“安全种子math/rand实例”的混合模式或者预生成一批随机字节缓存在内存中。6.3 一个真实的排查案例随机数生成器状态污染我曾经遇到一个诡异的bug一个后台批处理任务在连续处理多个任务时后面任务的“随机”行为竟然和前面任务一模一样。经过排查发现是因为多个任务函数都直接使用了包级别的全局rand.Intn而第一个任务在运行过程中消耗了全局生成器的大量状态导致第二个任务开始时生成器的内部状态已经前进到了一个确定但非预期的位置。虽然种子是随机的但序列的“起点”被第一个任务改变了。解决方案彻底弃用全局生成器重构代码让每个任务或每个模块都持有自己独立的rand.Rand实例并通过依赖注入传递。这不仅解决了bug也使代码更清晰、更易于测试。生成指定区间的随机数在Golang中是一个融合了数学基础、API理解、并发模型和性能考量的综合课题。从选择正确的随机源开始到精确推导整数和浮点数的区间转换公式再到规避并发陷阱和精度黑洞每一步都需要仔细斟酌。记住没有“银弹”在安全、性能、随机性和便利性之间取得平衡始终依赖于你对具体场景的深刻理解。希望这篇近万字的深度剖析能让你下次在写下rand.Intn时心中多一份笃定少踩一个坑。