随机数生成器仅生成一个随机数-Java 学习之路

673

我有以下功能：

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

为什么会这样？

9 回答

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

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

回复于 2024-04-24T13:59:24+08:00

有很多解决方案，这里有一个：如果你只想要数字擦除字母，方法会收到随机和结果长度 .

public String GenerateRandom(Random oRandom, int iLongitudPin)
{
    String sCharacters = "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ123456789";
    int iLength = sCharacters.Length;
    char cCharacter;
    int iLongitudNuevaCadena = iLongitudPin; 
    String sRandomResult = "";
    for (int i = 0; i < iLongitudNuevaCadena; i++)
    {
        cCharacter = sCharacters[oRandom.Next(iLength)];
        sRandomResult += cCharacter.ToString();
    }
    return (sRandomResult);
}

回复于 2024-04-24T13:59:24+08:00

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

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

回复于 2024-04-24T13:59:24+08:00

33
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);
```
干杯 .
回复于 2024-04-24T13:59:24+08:00

只需声明Random类变量，如下所示：

Random r = new Random();
    // ... Get three random numbers.
    //     Here you'll get numbers from 5 to 9
    Console.WriteLine(r.Next(5, 10));

如果你想从列表中每次获得不同的随机数，那么使用

r.Next(StartPoint,EndPoint) //Here end point will not be included

每次都声明 Random r = new Random() 一次 .

回复于 2024-04-24T13:59:24+08:00

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

测量这两个实现，你应该看到一个显着的差异 .

回复于 2024-04-24T13:59:24+08:00

1
我的答案来自here：

只是重申 the right solution ：
```
namespace mySpace
{
    public static class Util
    {
        private static rnd = new Random();
        public static int GetRandom()
        {
            return rnd.Next();
        }
    }
}
```
所以你可以打电话：
```
var i = Util.GetRandom();
```
一切都在 .

If you strictly need a true stateless static method 生成随机数，可以依靠 Guid .
```
public static class Util
{
    public static int GetRandom()
    {
        return Guid.NewGuid().GetHashCode();
    }
}
```
它会慢一点，但可能比 Random.Next 更随机，至少从我的经验来看 .

但 not ：
```
new Random(Guid.NewGuid().GetHashCode()).Next();
```
不必要的对象创建将使其变慢，尤其是在循环中 .

并且 never ：
```
new Random().Next();
```
它不仅速度慢（在循环内），它的随机性......根据我不是很好......
回复于 2024-04-24T13:59:24+08:00
923
每次执行
```
Random random = new Random (15);
```
如果你执行数百万次并不重要，你将始终使用相同的种子 .

如果你使用
```
Random random = new Random ();
```
你会得到不同的随机数序列，如果黑客猜到了种子并且你的算法与系统的安全性有关 - 你的算法就被打破了 . 我执行mult . 在此构造函数中，种子由系统时钟指定，如果在非常短的时间（毫秒）内创建了多个实例，则它们可能具有相同的种子 .

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

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);
```
回复于 2024-04-24T13:59:24+08:00
103
每次执行 new Random() 时，都会使用时钟进行初始化 . 这意味着在紧密循环中，您可以多次获得相同的值 . 您应该保留一个 Random 实例并继续在 same 实例上使用 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 实例的内部状态 . 如果我们从多个线程同时执行此操作，您可能会争论"we've just made the outcome even more random"，但我们实际上正在做的是可能破坏内部实现，我们也可以从不同的线程开始获取相同的数字，这可能是一个问题 - 并且也许不会 . 然而，保证内部发生的事情是更大的问题;因为 Random 确实 not 保证线程安全 . 因此有两种有效的方法：
- 同步，以便我们不会从不同的线程同时访问它
- 每个线程使用不同的 Random 个实例
两者都可以;但是同时从多个呼叫者那里静音一个 single 实例只是在惹麻烦 .

lock 实现了这些方法的第一个（也更简单）;但是，另一种方法可能是：
```
private static readonly ThreadLocal<Random> appRandom
     = new ThreadLocal<Random>(() => new Random());
```
这是每个线程，所以你不需要同步 .
回复于 2024-04-24T13:59:24+08:00

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

9 回答

相关问题