我有以下功能:
//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()
,都会使用时钟对其进行初始化。这意味着在紧密的循环中,您会多次获得相同的值。您应该保留一个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);
}
}
编辑(请参阅评论):为什么在这里需要lock
?
基本上, Next
将更改Random
实例的内部状态。如果我们同时在多个线程中执行此操作,则可能会争辩 “我们只是使结果更加随机”,但实际上 ,我们正在做的事情有可能破坏内部实现,并且我们也可能开始获得相同的数字从不同的线程,这可能是一个问题 - 可能不是。但是,保证内部发生的事情是更大的问题。因为Random
不能保证线程安全。因此,有两种有效的方法:
Random
实例两者都可以。但同时使多个调用者的单个实例静音只会带来麻烦。
lock
实现了这些方法中的第一个(并且更简单)。但是,另一种方法可能是:
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);
}
}
测量这两个实现,您应该会看到很大的不同。