我有以下功能:
//Function to get random number
public static int RandomNumber(int min, int max)
{
Random random = new Random();
return random.Next(min, max);
}
我怎么称呼它:
byte[] mac = new byte[6];
for (int x = 0; x < 6; ++x)
mac[x] = (byte)(Misc.RandomNumber((int)0xFFFF, (int)0xFFFFFF) % 256);
如果我在运行时使用调试器执行这个循环，我会得到不同的值（这就是我想要的）。但是，如果我在该代码的两行下面放一个断点，则MAC数组的所有成员都具有相等的值。
为什么会这样？
每次执行new Random()时，都会使用时钟进行初始化。这意味着在一个紧密的循环中，您会多次获得相同的值。您应该保留单个随机实例，并在同一实例上继续使用Next。
//Function to get a random number
private static readonly Random random = new Random();
private static readonly object syncLock = new object();
public static int RandomNumber(int min, int max)
{
lock(syncLock) { // synchronize
return random.Next(min, max);
}
}
编辑（见注释）:为什么这里需要一个锁？
基本上，next将更改random实例的内部状态。如果我们同时从多个线程中这样做，您可能会争辩说“我们只是使结果变得更加随机”，但我们实际上正在做的是潜在地破坏内部实现，并且我们还可能开始从不同的线程中获得相同的数字，这可能是一个问题--也可能不是。不过，对内部发生的事情的保证才是更大的问题；因为random不保证线程安全。因此，有两种有效的方法:
随机实例任何一个都可以是好的；但是同时互斥来自多个调用方的单个实例只是自找麻烦。
锁实现了这些方法中的第一种（也是更简单的）；然而，另一种办法可能是:
private static readonly ThreadLocal<Random> appRandom
= new ThreadLocal<Random>(() => new Random());
这是按线程执行的，因此不需要同步。
为了便于在整个应用程序中重用，静态类可能会有所帮助。
public static class StaticRandom
{
private static int seed;
private static ThreadLocal<Random> threadLocal = new ThreadLocal<Random>
(() => new Random(Interlocked.Increment(ref seed)));
static StaticRandom()
{
seed = Environment.TickCount;
}
public static Random Instance { get { return threadLocal.Value; } }
}
您可以使用然后使用静态随机实例，代码如下
StaticRandom.Instance.Next(1, 100);
Mark的解决方案可能相当昂贵，因为它需要每次同步。
我们可以通过使用特定于线程的存储模式来避免同步的需要:
public class RandomNumber : IRandomNumber
{
private static readonly Random Global = new Random();
[ThreadStatic] private static Random _local;
public int Next(int max)
{
var localBuffer = _local;
if (localBuffer == null)
{
int seed;
lock(Global) seed = Global.Next();
localBuffer = new Random(seed);
_local = localBuffer;
}
return localBuffer.Next(max);
}
}
测量这两种实现，您应该会看到一个显著的差异。
