Zufallszahlengenerator erzeugt nur eine Zufallszahl

Question

Ich habe die folgende Funktion:

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

Wie ich es nenne:

byte[] mac = new byte[6];
for (int x = 0; x < 6; ++x)
    mac[x] = (byte)(Misc.RandomNumber((int)0xFFFF, (int)0xFFFFFF) % 256);

Wenn ich diese Schleife mit dem Debugger während der Laufzeit durchlaufe, erhalte ich andere Werte (was ich ja auch will). Wenn ich jedoch zwei Zeilen unterhalb dieses Codes einen Haltepunkt setze, werden alle Mitglieder der mac Array haben den gleichen Wert.

Warum ist das so?

Answer 1

Jedes Mal, wenn Sie new Random() er wird mit Hilfe der Uhr initialisiert. Das bedeutet, dass Sie in einer engen Schleife viele Male denselben Wert erhalten. Sie sollten einen einzigen Zufällig Instanz und verwenden Sie weiterhin Weiter über die dieselbe Instanz.

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

---

Bearbeiten (siehe Kommentare): Warum brauchen wir eine lock hier?

Im Grunde genommen, Next wird den internen Zustand des Random Instanz. Wenn wir das gleichzeitig von mehreren Threads aus tun, können Sie pourrait "Wir haben das Ergebnis nur noch zufälliger gemacht", aber was wir tun, ist eigentlich Dies könnte die interne Implementierung zerstören, und wir könnten auch anfangen, dieselben Zahlen von verschiedenen Threads zu erhalten, was puede ein Problem sein - und vielleicht auch nicht. Die Garantie dessen, was intern geschieht, ist jedoch das größere Problem; denn Random hace no keine Garantien für die Sicherheit von Threads geben. Es gibt also zwei gültige Ansätze:

• Synchronisieren, damit wir nicht von verschiedenen Threads aus gleichzeitig darauf zugreifen
• Verwenden Sie verschiedene Random Instanzen pro Thread

Beides kann in Ordnung sein; aber das Mutexing einer einzeln Instanz von mehreren Anrufern zur gleichen Zeit ist einfach zu viel des Guten.

Le site lock erreicht den ersten (und einfacheren) dieser Ansätze; ein anderer Ansatz könnte jedoch sein:

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

dies ist dann pro Thread, so dass Sie nicht synchronisieren müssen.

Answer 2

Um die Wiederverwendung in Ihrer Anwendung zu erleichtern, kann eine statische Klasse hilfreich sein.

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

Sie können dann die statische Zufallsinstanz mit Code wie

StaticRandom.Instance.Next(1, 100);

Answer 3

Die Lösung von Mark kann ziemlich teuer sein, da sie jedes Mal synchronisiert werden muss.

Wir können die Notwendigkeit der Synchronisierung umgehen, indem wir das thread-spezifische Speichermuster verwenden:

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

Messen Sie die beiden Implementierungen und Sie sollten einen deutlichen Unterschied feststellen.

Answer 4

Meine Antwort von aquí :

Nur zur Wiederholung die richtige Lösung :

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

Sie können also anrufen:

var i = Util.GetRandom();

überall.

Wenn Sie unbedingt eine echte zustandslose statische Methode benötigen um Zufallszahlen zu generieren, können Sie sich auf eine Guid .

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

Es wird ein bisschen langsamer sein, aber es kann viel mehr Zufall sein. als Random.Next zumindest meiner Erfahrung nach.

Aber no :

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

Die unnötige Objekterzeugung wird es langsamer machen, besonders in einer Schleife.

Y niemals :

new Random().Next();

Es ist nicht nur langsamer (innerhalb einer Schleife), seine Zufälligkeit ist... nun, meiner Meinung nach nicht wirklich gut.

Answer 5

Ich würde lieber die folgende Klasse verwenden, um Zufallszahlen zu erzeugen:

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