随机数生成器仅生成一个随机数

Question

我有以下功能:

//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"数组的所有成员都具有相同的值.

为什么会这样？

Answer 1

每次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每个线程使用不同的实例

两者都可以; 但mutexing一个单一的在同一时间从多个来电实例找麻烦.

在lock实现这些方法的第一(和更简单); 然而,另一种方法可能是:

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

这是每个线程,所以你不需要同步.

Answer 2

为了便于在整个应用程序中重复使用,静态类可能会有所帮助.

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

Answer 3

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

测量两个实现,您应该看到显着的差异.

Answer 4

我在这里回答:

重申正确的解决方案:

namespace mySpace
{
    public static class Util
    {
        private static rnd = new Random();
        public static int GetRandom()
        {
            return rnd.Next();
        }
    }
}

所以你可以打电话:

var i = Util.GetRandom();

一切都在.

如果你真的需要一个真正的无状态静态方法来生成随机数,你可以依靠a Guid.

public static class Util
{
    public static int GetRandom()
    {
        return Guid.NewGuid().GetHashCode();
    }
}

它会慢一点,但可能比任何时候都要多Random.Next,至少从我的经验来看.

但不是:

new Random(Guid.NewGuid().GetHashCode()).Next();

不必要的对象创建会使它变慢,特别是在循环中.

而从未:

new Random().Next();

它不仅速度慢(在一个循环内),它的随机性......根据我不是很好......

Answer 5

我宁愿使用以下类来生成随机数:

byte[] random;
System.Security.Cryptography.RNGCryptoServiceProvider prov = new System.Security.Cryptography.RNGCryptoServiceProvider();
prov.GetBytes(random);

Answer 6

1)正如Marc Gravell所说,尝试使用一个随机发生器.将它添加到构造函数中总是很酷:System.Environment.TickCount.

2)一个提示.假设您要创建100个对象,并假设每个对象都应该有自己的随机生成器(如果您在很短的时间内计算随机数的LOADS,则会很方便).如果你在一个循环(生成100个对象)中这样做,你可以这样做(以确保完全随机性):

int inMyRandSeed;

for(int i=0;i<100;i++)
{
   inMyRandSeed = System.Environment.TickCount + i;
   .
   .
   .
   myNewObject = new MyNewObject(inMyRandSeed);  
   .
   .
   .
}

// Usage: Random m_rndGen = new Random(inMyRandSeed);

干杯.

Answer 7

每次执行

Random random = new Random (15);

执行数百万次都没有关系，您将始终使用相同的种子。

如果你使用

Random random = new Random ();

您会得到不同的随机数序列，如果黑客猜到了种子并且您的算法与系统的安全性有关 - 您的算法已损坏。我你执行多。在这个构造函数中，种子由系统时钟指定，如果在很短的时间（毫秒）内创建了多个实例，它们可能具有相同的种子。

如果您需要安全的随机数，则必须使用该类

System.Security.Cryptography.RNGCryptoServiceProvider

public static int Next(int min, int max)
{
    if(min >= max)
    {
        throw new ArgumentException("Min value is greater or equals than Max value.");
    }
    byte[] intBytes = new byte[4];
    using(RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
    {
        rng.GetNonZeroBytes(intBytes);
    }
    return  min +  Math.Abs(BitConverter.ToInt32(intBytes, 0)) % (max - min + 1);
}

用法：

int randomNumber = Next(1,100);

Answer 8

从 .NET 6 开始，该类Random现在配备了一个名为 的静态属性Shared：

提供可以从任何线程同时使用的线程安全的 Random 实例。

你可以这样使用它：

// Function to get random number
public static int RandomNumber(int min, int max)
{
    return Random.Shared.Next(min, max);
}

访问线程安全对象的开销很小，因此，如果您计划在单个线程上尽快生成数百万个随机数，那么最好创建一个专用Random实例，而不是依赖Shared.