我有以下功能：

//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

为什么会这样？

网友回答：

为了便于在整个应用程序中重用，静态类可能会有所帮助。

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);

网友回答：

每次执行此操作时，都会使用时钟进行初始化。这意味着在紧密循环中，您可以多次获得相同的值。您应该保留单个随机实例，并在同一实例上继续使用 Next。new Random()

//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

基本上，将更改实例的内部状态。如果我们同时从多个线程执行此操作，您可能会争辩说“我们只是使结果更加随机”，但我们实际上所做的可能会破坏内部实现，我们也可能开始从不同的线程获取相同的数字，这可能是一个问题 – 也可能不是。然而，保证内部发生的事情是更大的问题;因为不保证线程安全。因此，有两种有效的方法：NextRandomRandom

• 同步，这样我们就不会同时从不同的线程访问它
• 每个线程使用不同的实例Random

两者都可以;但是，同时从多个调用方对单个实例进行静音只是自找麻烦。

The achieves the first (and simpler) of these approaches; however, another approach might be:lock

private static readonly ThreadLocal<Random> appRandom
     = new ThreadLocal<Random>(() => new Random());

this is then per-thread, so you don’t need to synchronize.

网友回答：

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);
    }
}

测量这两个实现，您应该会看到显着差异。