Ces numéros aléatoires sont-ils 'sûrs'

Question

Je ne demande pas si ceux-ci sont vraiment aléatoires. Je voulais juste savoir si deux utilisateurs frappent la même page en même temps peuvent-ils obtenir le même nombre aléatoire? Je pense que si je cours ceci sur un serveur multicore je générerai le même nombre de randon une bonne quantité de temps dû à la synchronisation ou à d'autres raisons?

public static class SBackend 
{ 
    static Random randObj = null; 
    public static void init() 
    { 
     randObj = new Random((int)DateTime.Now.ToBinary()); 
     runFirstTime(); 
    } 

    public static long getRandomId() 
    { 
     long randNum = (long)randObj.Next() << 33; 
     randNum |= (uint)randObj.Next() << 2; 
     randNum |= (uint)randObj.Next() & 3; 
     return randNum; 
    } 
} 

Answer 1

Oui, il est possible que cela génère les mêmes nombres. La graine n'ajoute rien (c'est le temps par défaut de toute façon).

également - si elle est statique, vous devez synchronisez (Next est thread-safe):

static readonly Random rand = new Random(); 
public static int NextInt32() { 
    lock(rand) { return rand.Next();} 
} 
public static long NextInt64() { 
    lock(rand) { // using your algorithm... 
     long randNum = (long)rand.Next() << 33; 
     randNum |= (uint)rand.Next() << 2; 
     randNum |= (uint)rand.Next() & 3; 
     return randNum; 
    } 
} 

Cela peut encore générer le même nombre par hasard bien sûr ...

Peut-être envisager un générateur de nombres aléatoires cryptographiques si l'entropie est importante.

Answer 2

Bien, si vous ne l'utilisez que pour générer des nombres aléatoires qui ne sont jamais les mêmes, pourquoi ne pas utiliser System.Guid.NewGuid()?

Answer 3

Les générateurs de nombres pseudo-aléatoires (PRNG) sont seulement aussi bons que les valeurs de germe qu'ils ont. Maintenant, je vois que vous les avez définis comme des classes statiques et des méthodes statiques, donc en supposant que vous avez mis en place une sécurité pour s'assurer que getRandomId() n'est pas appelé par plusieurs threads simultanément, alors vous devriez être en forme OK. Toutefois, le verrouillage de l'accès à getRandomId entraînera un goulot d'étranglement et ne sera pas échelonné à l'infini lorsque votre trafic augmentera.

Answer 4

Vous pouvez utiliser le mécanisme de verrouillage qui garantit qu'un seul thread à la fois peut accéder à l'objet Random.

public static class ThreadSafeRandom 
{ 
    private static Random r = new Random(); 
    public static double NextDouble() 
    { 
     lock (r) 
     { 
      return r.NextDouble(); 
     } 
    } 

    public static int Next(int min, int max) 
    { 
     lock (r) 
     { 
      return r.Next(min, max); 
     } 
    } 
} 

Answer 5

Il est toujours possible que vous génériez le même numéro lorsque vous utilisez la classe Random de base. Je ferais mieux d'utiliser System.Security.Cryptography.RandomNumberGenerator qui va créer des valeurs aléatoires cryptographiquement fortes.

Answer 6

Vous pouvez utiliser un linear congruential generator dans une fonction synchronisée pour générer des nombres pseudo-aléatoires qui ne se répètent que toutes les requêtes m (voir l'article pour en écrire une). Faites m une valeur de 64 bits, et il devient très improbable que vous aurez jamais assez de demandes pour vous répéter, et encore moins pour servir le même nombre à deux visiteurs simultanés.

Answer 7

Comme d'autres l'ont dit, oui vous pouvez avoir deux valeurs aléatoires identiques si les deux threads demandent la valeur aléatoire dans la même graduation.

Voici une autre implémentation aléatoire sûre du thread. Celui-ci utilise moins de verrous par requête et est donc plus rapide.

public static class ThreadSafeRandom 
{ 
    private static Random _global = new Random(); 
    [ThreadStatic] 
    private static Random _local; 

    public static int Next() 
    { 
     Random inst = _local; 
     if (inst == null) 
     { 
      int seed; 
      lock (_global) seed = _global.Next(); 
      _local = inst = new Random(seed); 
     } 
     return inst.Next(); 
    } 
} 

Voir "Getting random numbers in a thread-safe way" par l'équipe Parallels pour plus d'informations.

Answer 8

Si vous voulez un numéro de session, utilisez un GUID.