Unity随机数进阶：超越Random.Range的加权随机、几何分布与状态管理实战

1. 项目概述：从Random.Range的舒适区走出来

如果你在Unity里做过任何需要随机性的功能，比如刷怪、抽卡、道具掉落或者地图生成，那你对Random.Range这个函数一定再熟悉不过了。它就像工具箱里那把最趁手的螺丝刀，简单直接，拿起来就能用。但问题是，很多开发者，包括一些有几年经验的朋友，工具箱里好像就只有这一把螺丝刀。需要拧螺丝用它，需要撬东西也用它，甚至需要敲钉子的时候，还是试图用它去敲——结果就是要么功能实现得磕磕绊绊，要么程序运行起来总有些难以捉摸的“小毛病”。

Random.Range确实好用，但它只是Unity随机数系统（UnityEngine.Random类）的冰山一角。这个类底下藏着不少更强大、更精细的工具，能帮你解决Random.Range搞不定的问题，或者让你的随机逻辑更健壮、更可控。今天我们不聊那些深奥的数学原理，就从一个干了十多年游戏开发的老兵视角，分享几个我踩过坑、救过急的实战技巧。这些技巧能帮你处理更复杂的随机需求，比如“带权重的随机选择”、“可重复的随机序列”、“在球面上均匀撒点”，以及如何避免那些让随机数“不随机”的常见陷阱。别再只用Random.Range了，是时候升级你的随机工具箱了。

2. 核心需求解析：为什么Random.Range不够用？

在深入技巧之前，我们得先搞清楚，光靠Random.Range会遇到哪些天花板。理解了这些痛点，你才能明白后面那些技巧的价值所在。

2.1 需求一：非均匀概率分布（加权随机）

这是最经典的需求。Random.Range(0, 3)给你0、1、2三个整数，每个概率是均等的33.3%。但现实需求往往是：掉落普通道具的概率是70%，稀有道具25%，史诗道具5%。你用Random.Range硬写也不是不行，但代码会变得又臭又长，而且不易维护和调整。

// 笨拙的写法：逻辑分散，不易读 int randomValue = Random.Range(0, 100); if (randomValue < 70) { // 普通道具 } else if (randomValue < 95) // 70 + 25 = 95 { // 稀有道具 } else { // 史诗道具 }

当道具类型增加到10种、20种时，这段代码会变成一场维护噩梦。我们需要一种更优雅、声明式的权重配置和选择方法。

2.2 需求二：可重复的随机序列

游戏开发中经常需要“确定性随机”。比如，你用随机种子生成了一张地图，希望玩家每次用同一个“地图种子”都能得到完全一样的地图布局。或者，在联网游戏中，为了保持所有客户端状态同步，你们需要一套生成完全相同随机序列的机制。标准的Random.Range依赖于全局的随机状态，一旦被调用，状态就改变了，无法简单地“回退”或“重现”某个特定序列。你需要能够创建独立的、自带状态的随机数生成器（RNG）实例。

2.3 需求三：特定几何空间内的随机

Random.Range只能给你一条直线（一维）或一个平面矩形区域（二维通过组合）上的随机点。但很多需求是三维的、非矩形的。比如：

• 在一个圆形或环形区域内随机生成敌人。
• 在一个球体表面或内部均匀地生成星星。
• 沿着一条曲线（如贝塞尔曲线）随机分布物体。 这些都需要额外的数学处理，直接Random.Range出来的点分布是不均匀的（例如在圆内直接随机角度和半径，点会向中心聚集）。

2.4 需求四：随机序列的“洗牌”与采样

从一个集合（如牌组、怪物列表、任务池）中随机抽取若干个不重复的元素。用Random.Range去索引并移除元素，在集合较大时效率会越来越低（因为要移动数组元素）。我们需要高效的“洗牌”算法（如Fisher-Yates）和“无放回随机采样”算法。

2.5 需求五：随机状态的隔离与管理

Unity的Random类是静态类，其状态（种子、内部迭代器）是全局共享的。这带来了一个隐藏风险：A系统调用了Random.Range，改变了全局随机状态，可能导致B系统接下来生成的随机数偏离预期。在大型项目中，多个模块（AI决策、特效播放、 loot生成）如果都依赖全局随机，会形成难以调试的耦合和不确定性。我们需要将随机状态“局部化”。

3. 实战技巧一：实现优雅的加权随机选择

加权随机，或者说按概率分布随机，是游戏设计的基石。上面提到了笨拙的if-else链，我们来看看更专业的做法。

3.1 方法一：别名采样法（Alias Method）—— 适用于大量选项

当你的选项非常多（比如成百上千个），并且需要频繁抽样时，别名采样法是时间复杂度O(1)的王者。它的原理有点复杂，但思想是巧妙的：将每个选项的概率“拆分”和“组合”，最终构建一个结构，使得每次抽样只需要生成两个随机数并进行一次数组查找。

对于大多数日常游戏开发，我们可能不需要自己实现完整的别名采样。但要知道有这种高效方案存在，对于道具库极其庞大的游戏（如某些ARPG或抽卡游戏），在性能优化阶段值得考虑。Unity本身没有内置，但社区有优秀的实现库。

3.2 方法二：累计概率区间法 —— 最直观实用的方法

这是最常用、也最容易理解的方法。我们为每个选项计算一个累计概率的“右边界”，然后生成一个0到总权重之间的随机数，看它落在哪个区间。

using System; using System.Collections.Generic; using UnityEngine; public class WeightedRandomSelector<T> { [System.Serializable] public struct Item { public T value; public float weight; } private List<Item> _items; private float _totalWeight; private bool _isDirty; // 标记权重是否被修改，需要重新计算 public WeightedRandomSelector() { _items = new List<Item>(); _totalWeight = 0f; _isDirty = true; } public void Add(T value, float weight) { if (weight <= 0) { Debug.LogWarning($"添加的项权重必须大于0，当前权重：{weight}。该项将被忽略。"); return; } _items.Add(new Item { value = value, weight = weight }); _isDirty = true; } public T GetRandom() { if (_items.Count == 0) { throw new InvalidOperationException("随机选择器中没有添加任何项。"); } if (_isDirty) { CalculateTotalWeight(); } float randomPoint = UnityEngine.Random.Range(0f, _totalWeight); float cumulativeWeight = 0f; // 注意：这里使用for循环比foreach稍快，且在Unity中更常见 for (int i = 0; i < _items.Count; i++) { cumulativeWeight += _items[i].weight; if (randomPoint <= cumulativeWeight) { return _items[i].value; } } // 理论上不会走到这里，除非浮点数精度问题。兜底返回最后一项。 return _items[_items.Count - 1].value; } private void CalculateTotalWeight() { _totalWeight = 0f; for (int i = 0; i < _items.Count; i++) { _totalWeight += _items[i].weight; } _isDirty = false; } }

使用示例与心得：

// 初始化一个掉落物选择器 var lootSelector = new WeightedRandomSelector<string>(); lootSelector.Add("普通药水", 70f); lootSelector.Add("稀有戒指", 25f); lootSelector.Add("史诗武器", 5f); // 模拟10000次掉落，验证概率分布 Dictionary<string, int> countDict = new Dictionary<string, int>(); int trials = 10000; for (int i = 0; i < trials; i++) { string loot = lootSelector.GetRandom(); if (countDict.ContainsKey(loot)) countDict[loot]++; else countDict[loot] = 1; } foreach (var kvp in countDict) { Debug.Log($"{kvp.Key}: 出现次数 {kvp.Value}, 实际概率 {(float)kvp.Value / trials:P2}"); } // 输出应接近：普通药水: ~70%, 稀有戒指: ~25%, 史诗武器: ~5%

注意：浮点数精度问题。当权重值非常小或总权重非常大时，浮点数的累加可能产生微小误差。上面的兜底逻辑就是为此准备的。对于要求极端精确的场景（如涉及真金白银的抽卡），可以考虑使用整数权重（如 7000， 2500， 500），或者使用高精度的decimal类型进行计算（但Random.Range不支持decimal，需要转换）。

实操心得：我习惯将这类选择器设计成可序列化的，这样就能在Inspector窗口中直观地配置权重，对于策划调整数值非常友好。你可以将List<Item> _items改为public或者使用[SerializeField] private List<Item> items;，再配合一个自定义Editor脚本，就能在编辑器里拖拽配置了。

4. 实战技巧二：创建可预测的随机数生成器

全局的UnityEngine.Random就像一块公用的黑板，谁都可以上去写写画画，你无法回溯之前写了什么。要获得可预测的、独立的随机序列，我们需要自己的“私人笔记本”——即System.Random类的实例。

4.1 使用System.Random获得独立状态

System.Random是 .NET 框架中的伪随机数生成器类。你可以创建它的多个实例，每个实例都有自己的内部状态，互不干扰。

using System; // 注意是System，不是UnityEngine public class DeterministicMapGenerator { private System.Random _rng; public DeterministicMapGenerator(int seed) { // 用指定的种子初始化随机数生成器 _rng = new System.Random(seed); Debug.Log($"地图生成器已初始化，种子：{seed}"); } public int NextInt(int minInclusive, int maxExclusive) { // System.Random.Next(min, max) 的max是独占的，与Unity的Random.Range(int, int)行为一致 return _rng.Next(minInclusive, maxExclusive); } public float NextFloat() { // System.Random.NextDouble() 返回 [0.0, 1.0) 的双精度浮点数 return (float)_rng.NextDouble(); } public float NextFloat(float minInclusive, float maxInclusive) { // 将其映射到指定范围。注意：NextDouble()是[0,1)，要模拟Unity的[max] inclusive需要一点技巧。 // 一个简单近似是使用 maxInclusive - minInclusive 的微小容差。 // 更严谨的做法是使用 NextDouble() * (maxInclusive - minInclusive) + minInclusive; // 但由于浮点精度，maxInclusive可能极难达到。通常游戏逻辑可以接受[max] exclusive。 float range = maxInclusive - minInclusive; return (float)_rng.NextDouble() * range + minInclusive; } }

关键区别与注意事项：

重要提示：UnityEngine.Random.Range(float, float)的第二个参数是包含（inclusive）的，而System.Random.NextDouble()返回的是右开区间[0.0, 1.0)。这意味着你无法通过简单的线性变换得到一个严格包含上限的浮点数。在大多数游戏逻辑中（比如随机位置、随机伤害），[min, max)的区间已经足够，因为恰好抽到上限值的概率在数学上是0。如果业务逻辑必须包含上限，可以考虑生成一个[0, 1]的整数随机数，或者接受一个极其接近上限的值。

4.2 应用场景：地图生成与网络同步

场景一：可分享的地图种子

public class ProceduralWorld { private System.Random _terrainRng; private System.Random _decorRng; public void GenerateWorld(string seedString) { // 将字符串种子转换为整数。使用GetHashCode，相同字符串得到相同整数。 int seed = seedString.GetHashCode(); _terrainRng = new System.Random(seed); // 可以用派生种子来生成不同的但确定的序列，避免干扰。 _decorRng = new System.Random(seed + 1); GenerateTerrain(_terrainRng); PlaceTreesAndRocks(_decorRng); // ... 玩家输入同一个种子，得到的世界一模一样 } }

场景二：网络游戏的确定性逻辑在锁步同步的RTS或MOBA游戏中，所有客户端必须保持完全一致的随机序列，以确保公平性。通常由主机或服务器权威生成随机种子，或直接广播随机事件结果。客户端可以使用相同的种子初始化自己的System.Random实例，来重现非权威的视觉效果（如伤害飘字、粒子效果），但核心逻辑（如暴击判定）的随机数必须来自权威源。

实操心得：我强烈建议在项目早期就规划好随机数的使用策略。将核心的、影响游戏结果的随机逻辑（如战斗计算、 loot生成）与纯视觉的随机效果（如屏幕抖动、粒子颜色）分离开。核心逻辑使用System.Random实例并妥善管理种子，视觉特效可以放心使用UnityEngine.Random。这样既能保证确定性，又能享受Unity全局随机的便利。

5. 实战技巧三：在特定几何空间内生成随机点

直接组合Random.Range来生成随机点，在非矩形区域会导致分布不均。下面介绍几种常见几何空间的正确生成方法。

5.1 在圆内均匀随机

错误的方法是随机一个半径r和角度θ，然后转换成坐标(r*cosθ, r*sinθ)。这样生成的点会在圆心处更密集，因为面积元dA = r dr dθ，半径小的环面积小，但点密度相同，所以圆心处点的实际面密度更高。

正确的方法是先随机半径的平方根，以保证点在圆内均匀分布。

public static Vector2 RandomPointInCircle(float radius) { // 1. 随机角度 float angle = UnityEngine.Random.Range(0f, Mathf.PI * 2f); // 2. 随机半径：为了均匀分布，需要对半径的平方进行均匀随机，再开方。 float r = Mathf.Sqrt(UnityEngine.Random.Range(0f, 1f)) * radius; float x = Mathf.Cos(angle) * r; float y = Mathf.Sin(angle) * r; return new Vector2(x, y); } // 三维版本（在XZ平面上的圆盘） public static Vector3 RandomPointInCircleXZ(float radius) { float angle = UnityEngine.Random.Range(0f, Mathf.PI * 2f); float r = Mathf.Sqrt(UnityEngine.Random.Range(0f, 1f)) * radius; float x = Mathf.Cos(angle) * r; float z = Mathf.Sin(angle) * r; return new Vector3(x, 0f, z); }

5.2 在球面上均匀随机（随机方向）

生成一个随机的、均匀分布在球面上的单位向量，常用于发射子弹、随机初始速度等。 错误的方法是随机经度和纬度，这会在两极产生聚集。正确的方法是使用正态分布或拒绝采样法。最常用的是Marsaglia的“正态分布”方法，但Unity提供了一个更简单且正确的方法：在一个单位立方体内随机取点，然后归一化。

public static Vector3 RandomOnUnitSphere() { // 方法一：使用Unity内置方法（最简单） // return UnityEngine.Random.onUnitSphere; // 方法二：手动实现（理解原理） Vector3 point; do { // 在[-1,1]的立方体内随机取点 point = new Vector3( UnityEngine.Random.Range(-1f, 1f), UnityEngine.Random.RandomRange(-1f, 1f), UnityEngine.Random.Range(-1f, 1f) ); } while (point.sqrMagnitude > 1f || point.sqrMagnitude < 0.0001f); // 拒绝在单位球外的点，也避免零向量 return point.normalized; // 归一化得到球面上的点 }

5.3 在球体内均匀随机

类似于圆内，在球体内均匀随机也需要对半径的立方根进行处理。

public static Vector3 RandomPointInSphere(float radius) { // 1. 随机一个球面上的方向 Vector3 direction = UnityEngine.Random.onUnitSphere; // 2. 随机半径：为了均匀分布，需要对半径的立方进行均匀随机，再开立方。 float r = Mathf.Pow(UnityEngine.Random.Range(0f, 1f), 1f / 3f) * radius; return direction * r; }

实操心得：这些几何随机函数非常常用，我建议你将其封装到一个静态工具类中，比如RandomGeometry。在需要的地方直接调用，避免每次都要重新推导或查找公式。对于性能极其敏感的场景（如每帧生成大量粒子），可以预先计算好Mathf.PI * 2f等常量，并考虑使用Unity.Mathematics中的Random结构体，它在Burst编译下性能更高。

6. 实战技巧四：高效随机采样与洗牌算法

从一个集合中随机抽取元素，有放回和无放回是两种基本操作。

6.1 无放回随机采样（Fisher-Yates洗牌算法）

如果你有一个数组，想把它随机打乱顺序（比如洗牌），或者想从中依次取出若干个不重复的随机元素，Fisher-Yates算法是标准且高效的选择。它的时间复杂度是O(n)。

public static class RandomUtility { // Fisher-Yates洗牌，直接打乱原数组 public static void Shuffle<T>(this IList<T> list) { int n = list.Count; for (int i = n - 1; i > 0; i--) { // 在[0, i]区间内随机选择一个索引j int j = UnityEngine.Random.Range(0, i + 1); // 交换元素list[i]和list[j] T temp = list[i]; list[i] = list[j]; list[j] = temp; } } // 从列表中随机抽取k个不重复的元素（不修改原列表） public static List<T> SampleWithoutReplacement<T>(this IList<T> source, int k) { if (k > source.Count) { throw new ArgumentException($"采样数量k({k})不能大于源列表长度({source.Count})。"); } // 创建一个副本用于内部洗牌操作 List<T> copy = new List<T>(source); List<T> result = new List<T>(k); int n = copy.Count; for (int i = 0; i < k; i++) { // 每次在剩余部分随机选一个 int randomIndex = UnityEngine.Random.Range(i, n); result.Add(copy[randomIndex]); // 将选中的元素交换到当前位置i，确保不会被再次选中 T temp = copy[randomIndex]; copy[randomIndex] = copy[i]; copy[i] = temp; } return result; } }

使用示例：

// 洗牌示例 List<Card> deck = GetDeck(); deck.Shuffle(); // 牌组现在已被打乱 // 无放回采样示例 List<Monster> monsterPool = GetAllMonsters(); List<Monster> selectedMonsters = monsterPool.SampleWithoutReplacement(5); // 随机选5种不同的怪物 foreach (var monster in selectedMonsters) { SpawnMonster(monster); }

6.2 有放回随机采样

这就是最简单的用Random.Range做索引。但当采样次数非常多时，需要注意性能。如果列表长度固定，可以预先计算一次list.Count存入局部变量，避免在循环中反复查询属性。

// 高效的有放回采样 int count = myList.Count; // 预先计算 for (int i = 0; i < 1000; i++) { int index = UnityEngine.Random.Range(0, count); var item = myList[index]; // ... 处理item }

实操心得：Fisher-Yates洗牌算法的一个关键点是循环方向。上面例子是从后往前（i = n-1; i > 0; i--），也可以从前往后。重要的是，随机索引j的范围是[0, i]或[i, n-1]，确保每个位置都有机会被交换。这个算法是“原地”的，会修改原数组。如果你需要保留原列表，记得先创建一个副本。

7. 实战技巧五：管理随机状态，避免副作用

全局状态是滋生Bug的温床。当你的游戏系统越来越复杂，音频系统、特效系统、AI系统、游戏逻辑系统都可能调用UnityEngine.Random，它们会相互污染随机数序列。

7.1 问题重现：随机数序列被意外干扰

假设你有一个抽卡系统，在抽卡前先播一段随机的闪光特效。特效系统调用Random.Range来随机颜色，这改变了全局随机状态。紧接着你的抽卡逻辑也调用Random.Range，得到的“随机”结果实际上已经被特效逻辑影响了。在单机游戏中，这可能只是让结果变得不可预测（但未必是坏事）。但在需要确定性重现的场合（如录像回放、网络同步），这就是灾难。

7.2 解决方案：隔离与封装

策略一：为关键系统使用独立的System.Random实例正如技巧二所介绍的，将影响游戏核心进程的随机逻辑（如伤害计算、 loot判定、AI决策）封装到独立的类中，并使用System.Random实例。

public class CombatSystem { private System.Random _combatRng; private int _seed; public void Initialize(int seed) { _seed = seed; _combatRng = new System.Random(seed); } public bool TryCriticalHit(float baseRate) { // 使用独立的RNG进行暴击判定 double roll = _combatRng.NextDouble(); return roll < baseRate; } public void ResetWithSeed(int newSeed) { // 重置随机状态，用于录像回放或重新开始 _combatRng = new System.Random(newSeed); } }

策略二：保存与恢复全局随机状态如果某些遗留代码或第三方插件必须使用UnityEngine.Random，而你需要在它们执行前后保持你序列的纯净，可以保存和恢复状态。UnityEngine.Random.state属性允许你获取和设置完整的内部状态。

public class RandomStateScope : IDisposable { private Random.State _previousState; public RandomStateScope(int seed) { // 进入作用域时，保存当前状态，并初始化新种子 _previousState = Random.state; Random.InitState(seed); } public void Dispose() { // 离开作用域时，恢复之前的状态 Random.state = _previousState; } } // 使用示例 void MyDeterministicFunction() { // 在using块内，Random的状态是独立的 using (new RandomStateScope(12345)) { int a = Random.Range(0, 100); int b = Random.Range(0, 100); // a和b将由种子12345确定性地生成 } // 离开using块后，全局Random状态恢复到进入前的样子 int c = Random.Range(0, 100); // 不受上面种子影响 }

警告：频繁地保存和恢复Random.state会有一定的性能开销，因为它涉及拷贝一个结构体。不要在每帧或高频循环中使用。它更适合用于隔离一些确定性的、一次性的生成过程。

策略三：使用Unity.Mathematics.Random（面向高性能和ECS）如果你在使用DOTS/ECS架构，或者对性能有极致要求，Unity.Mathematics.Random是一个更好的选择。它是一个值类型（struct），可以存储在组件中，完美契合ECS范式，并且可以与Burst编译器协同工作，获得极高的运行效率。

using Unity.Mathematics; // 在Component或System中 public struct MyRandomComponent : IComponentData { public Random rng; } // 初始化 var myRng = new Random(12345); // 使用 int randomInt = myRng.NextInt(0, 100); float randomFloat = myRng.NextFloat();

实操心得：在项目初期就建立随机数使用规范。我的团队通常约定：所有游戏逻辑（Gameplay）相关的随机，必须使用注入的System.Random实例或Unity.Mathematics.Random。所有视觉效果、音频等不影响核心逻辑的随机，可以使用UnityEngine.Random。代码审查时，会特别检查对全局Random的滥用。这条规矩帮我们避免了许多难以复现的诡异Bug。

8. 常见问题与排查技巧实录

即使掌握了上面的技巧，在实际开发中还是会遇到各种奇怪的问题。下面是我总结的几个高频“坑点”和解决方法。

8.1 问题一：随机数看起来“不随机”，有规律或聚集

现象：生成的随机数序列看起来有模式，比如连续出现几个相近的数，或者奇偶交替。可能原因与排查：

1. 种子问题：如果你在每帧或每次调用时都使用new Random(DateTime.Now.Millisecond)或Random.InitState(Time.frameCount)，由于计算机速度很快，可能连续几次获取到相同或相近的时间戳，导致种子几乎一样，生成的序列开头部分自然也相似。
   • 解决：对于需要唯一性的随机序列，使用更可靠的种子源，如Guid.NewGuid().GetHashCode()，或结合时间与硬件信息。
2. 范围太小：如果你在很小的范围内（比如Random.Range(0, 2)）生成大量随机数，出现连续多次相同结果在统计学上是正常的，但人眼会觉得“不随机”。
   • 解决：理解这是概率的正常体现。如果需要减少这种“连续感”，可以引入一些简单的平滑逻辑，比如“如果连续3次出现1，则强制下一次为0”，但这会破坏真正的随机性，慎用。
3. 使用了错误的分布：如前面提到的，在圆内直接随机半径会导致点向中心聚集，这不是随机数生成器的问题，而是数学方法的问题。
   • 解决：回顾技巧三，确保在特定几何空间内使用了正确的采样方法。

8.2 问题二：随机结果在编辑器模式和打包后不一致

现象：在Unity编辑器中运行正常，但打包成exe后，随机生成的地图、敌人布局等完全不同。可能原因与排查：

1. 种子来源不一致：如果你的种子依赖于System.DateTime.Now或Environment.TickCount，在编辑器（多线程、刷新率不稳定）和独立播放器中的执行环境有差异，获取到的时间戳可能不同。
   • 解决：使用确定的种子进行测试。在发布版本中，如果需要随机种子，可以使用更稳定的源，如玩家输入的字符串哈希，或从系统获取的经过处理的时间（如((int)DateTime.UtcNow.Ticks)）。
2. 代码执行顺序差异：编辑器和打包后，某些初始化的Awake/Start/OnEnable执行顺序可能微妙不同。如果随机数生成依赖于这些初始化过程，而生成器本身又在Awake中初始化，就可能因顺序问题导致第一个随机数不同，进而引发蝴蝶效应。
   • 解决：确保所有依赖随机数生成器的系统，其初始化顺序是明确的。可以使用脚本执行顺序设置，或通过一个统一的GameManager在Start中按顺序初始化所有子系统。

8.3 问题三：多线程环境下随机数生成崩溃或异常

现象：在使用Job System或普通多线程时，调用UnityEngine.Random或System.Random实例导致崩溃或数据竞争。可能原因与排查：

1. UnityEngine.Random非线程安全：绝对不能在子线程中调用UnityEngine.Random的任何方法。
   • 解决：在主线程生成好随机数，再将结果传递给Job。或者，在Job内部使用Unity.Mathematics.Random，它是线程安全的（因为它是值类型，每个Job实例拥有自己的副本）。
2. 共享System.Random实例：多个线程同时调用同一个System.Random实例的Next()方法，会导致内部状态损坏，可能抛出异常或返回错误结果。
   • 解决：为每个线程创建独立的System.Random实例。注意，如果同时创建，不要使用相同的种子（如都使用DateTime.Now），否则它们会产生相同序列。可以使用线程ID或一个全局的原子计数器来生成不同的种子。

// 错误示例 private System.Random _sharedRng = new System.Random(); void ParallelJob() { Parallel.For(0, 1000, i => { int num = _sharedRng.Next(); // 多线程竞争，危险！ }); } // 正确示例 void ParallelJob() { Parallel.For(0, 1000, i => { // 每个线程/task有自己的RNG，种子由线程ID和主种子混合生成 var localRng = new System.Random(Environment.CurrentManagedThreadId ^ _mainSeed); int num = localRng.Next(); }); }

8.4 随机数使用自查清单

在提交代码前，可以快速过一遍这个清单：

• [ ]确定性需求：这个功能需要录像回放或网络同步吗？如果是，必须使用System.Random或Unity.Mathematics.Random并管理好种子。
• [ ]全局状态污染：这个随机调用会影响到其他模块吗？考虑将其隔离。
• [ ]几何分布：我需要在圆、球体、球面上生成点吗？使用了正确的公式吗？
• [ ]性能：需要在循环中生成大量随机数吗？考虑使用更高效的库（如Unity.Mathematics）或预先生成数组。
• [ ]线程安全：这段代码会在子线程或Job中运行吗？绝对不能使用UnityEngine.Random。
• [ ]范围检查：Random.Range(int, int)和Random.Range(float, float)的第二个参数含义不同（exclusive vs inclusive），我用对了吗？

最后，关于随机数，我最深的一点体会是：“真随机”在计算机中是不存在的，我们用的都是“伪随机”。但这恰恰是游戏开发所需要的——可控、可重现、可调试的随机。把UnityEngine.Random当成一把万能钥匙，迟早会碰到打不开的锁。花点时间了解并善用System.Random、加权随机、几何随机和洗牌算法，就像是给你的工具箱添置了撬锁器、扳手和螺丝刀套装。当需求再次来临时，你就能从容地选出最合适的那把工具，干净利落地解决问题。