Modo corretto per utilizzare Casuale nell'applicazione multithread

Question

Ok. Ecco quello che so che non funziona:

int Rand() 
{ 
    //will return the same number over and over again 
    return new Random().Next(); 
} 

static Random rnd=new Random(); 

int Rand() 
{ 
    //if used like this from multiple threads, rnd will dissintegrate 
    //over time and always return 0 
    return rnd.Next(); 
} 

Ciò funzionerà correttamente, ma se usato da più thread, l'utilizzo della CPU va verso l'alto, che io non voglio, e che credo non sia necessaria:

int Rand() 
{ 
    lock(rnd) 
    { 
     return rnd.Next(); 
    } 
} 

Quindi, c'è una classe Random thread-safe per C#, o un modo migliore per usarlo?

Answer 1

io uso qualcosa di simile:

public static class StaticRandom 
{ 
    static int seed = Environment.TickCount; 

    static readonly ThreadLocal<Random> random = 
     new ThreadLocal<Random>(() => new Random(Interlocked.Increment(ref seed))); 

    public static int Rand() 
    { 
     return random.Value.Next(); 
    } 
} 

Answer 2

penso che quello che vuoi è ThreadStatic

[ThreadStatic] 
static Random rnd=new Random(); 

int Rand() 
{ 
    if (rnd == null) 
    { 
     rnd = new Random() 
    } 
    //Now each thread gets it's own version 
    return rnd.Next(); 
} 

In questo modo ogni thread ottenere la propria versione della vostra proprietà RND

Il motivo per il vostro blocco aumenterà l'utilizzo della CPU è perché tutte le discussioni aspetteranno in quel punto singolo (dovrebbe essere un problema solo se lo si utilizza molto)

[Aggiornamento] Ho corretto l'inizializzazione. Come qualcuno ha sottolineato, lascia il fatto che se si avviano più thread nello stesso millisecondo, essi produrranno gli stessi risultati.

Answer 3

readonly ThreadLocal<Random> random = 
    new ThreadLocal<Random>(() => new Random(GetSeed())); 

int Rand() 
{ 
    return random.Value.Next(); 
} 

static int GetSeed() 
{ 
    return Environment.TickCount * Thread.CurrentThread.ManagedThreadId; 
} 

(spudoratamente rubato dal commento di Jeroen Vannevel)

Answer 4

Il mio gruppo ha recentemente esaminato questo. Siamo giunti alla conclusione che dovremmo utilizzare un generatore di numeri casuali appositamente progettato per supportare il calcolo parallelo. La libreria del generatore di numeri casuali di Tina (http://numbercrunch.de/trng/) ha un'implementazione stabile e un manuale con un'introduzione teorica e riferimenti alla letteratura pertinente. Finora, ne siamo molto soddisfatti.