blocks|key|1221695|text|在Next方法中没有做任何特殊的事情来实现线程安全。然而，它是一个实例方法。如果您不跨不同的线程共享Random的实例，则不必担心实例中的状态损坏。在没有持有某种排它锁的情况下，不要跨不同的线程使用Random的单个实例。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1221696|Jon+Skeet在这个主题上有几个很好的帖子：|1221697|StaticRandom|1221698|Revisiting+randomness|1221699|正如一些评论员所指出的，在使用不同的Random实例时存在另一个潜在的问题，这些实例是线程独占的，但是被相同地播种，因此导致相同的伪随机数序列，因为它们可能是在同一时间创建的，或者彼此在时间上非常接近。缓解该问题的一种方法是使用主Random实例(由单个线程锁定)来生成一些随机种子，并初始化新的Random实例，供每个其他线程使用。|1221700|entityMap|0|LINK|mutability|MUTABLE|url|https://jonskeet.uk/csharp/miscutil/usage/staticrandom.html|1|http://codeblog.jonskeet.uk/2009/11/04/revisiting-randomness/^0|1|4|1E|6|2R|6|0|0|0|C|0|C|0|0|0|L|1|0|I|6|37|6|44|6|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|J|3|K|5|6|7|1B|8|@]|D|@$9|1C|A|1D|1|1E]]|E|$]]|$1|L|3|M|5|6|7|1F|8|@$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]|$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]|V|$5|Q|R|S|E|$T|W]]]]

There's nothing special done in the <code>Next</code> method to achieve thread safety. However, it's an instance method. If you don't share instances of <code>Random</code> across different threads, you don't have to worry about state corruption within an instance. Do not use a single instance of <code>Random</code> across different threads without holding an exclusive lock of some sort.

Jon Skeet has a couple nice posts on this subject:

<a href="https://jonskeet.uk/csharp/miscutil/usage/staticrandom.html" rel="noreferrer"><code>StaticRandom</code></a> 
<a href="http://codeblog.jonskeet.uk/2009/11/04/revisiting-randomness/" rel="noreferrer">Revisiting randomness</a>

As noted by some commentators, there is another potential problem in using different instances of <code>Random</code> that are thread-exclusive, but are seeded identically, and therefore induce the identical sequences of pseudorandom numbers, because they may be created at the same time or within close temporal proximity of each other. One way to alleviate that issue is to use a master <code>Random</code> instance (which is locked by a single thread) to generate some random seeds and initialize new <code>Random</code> instances for every other thread to use.

blocks|key|1007448|text|不，它不是线程安全的。如果你需要从不同的线程使用同一个实例，你必须同步使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1007449|不过，我真的看不出你有什么理由需要它。对于每个线程来说，拥有自己的Random类实例会更有效率。|1007450|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

No, it's not thread safe. If you need to use the same instance from different threads, you have to synchronise the usage.

I can't really see any reason why you would need that, though. It would be more efficient for each thread to have their own instance of the Random class.

blocks|key|1221918|text|另一种线程安全的方法是使用ThreadLocal<T>，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1221919|new+ThreadLocal<Random>(()+=>+new+Random(GenerateSeed()));|code-block|syntax|javascript|1221920|每次调用GenerateSeed()方法时，它都需要返回一个唯一的值，以确保随机数序列在每个线程中是唯一的。|1221921|static+int+SeedCount+=+0;
static+int+GenerateSeed()+{+
++++return+(int)+((DateTime.Now.Ticks+<<+4)+%2B+
+++++++++++++++++++(Interlocked.Increment(ref+SeedCount)));+
}|1221922|将适用于少量线程。|1221923|entityMap^0|D|E|0|0|4|E|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

Another thread safe way is to use <code>ThreadLocal&lt;T&gt;</code> as follows:

<pre><code>new ThreadLocal&lt;Random&gt;(() =&gt; new Random(GenerateSeed()));
</code></pre>

The <code>GenerateSeed()</code> method will need to return a unique value each time it is called to assure that the random number sequences are unique in each thread.

<pre><code>static int SeedCount = 0;
static int GenerateSeed() { 
 return (int) ((DateTime.Now.Ticks &lt;&lt; 4) + 
 (Interlocked.Increment(ref SeedCount))); 
}
</code></pre>

Will work for small numbers of threads.

blocks|key|1007687|text|无论如何，这里是一个继承了Random的线程安全的、加密的强RNG。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1007688|为了便于使用，实现包括静态入口点，它们与公共实例方法具有相同的名称，但以"Get“为前缀。|1007689|对RNGCryptoServiceProvider.GetBytes的调用是一个相对昂贵的操作。通过使用内部缓冲区或“池”来降低RNGCryptoServiceProvider的使用频率和效率，可以缓解这种情况。如果应用程序域中只有几代，那么这可以被视为开销。|1007690|using+System;
using+System.Security.Cryptography;

public+class+SafeRandom+:+Random
{
++++private+const+int+PoolSize+=+2048;

++++private+static+readonly+Lazy<RandomNumberGenerator>+Rng+=
++++++++new+Lazy<RandomNumberGenerator>(()+=>+new+RNGCryptoServiceProvider());

++++private+static+readonly+Lazy<object>+PositionLock+=
++++++++new+Lazy<object>(()+=>+new+object());

++++private+static+readonly+Lazy<byte[]>+Pool+=
++++++++new+Lazy<byte[]>(()+=>+GeneratePool(new+byte[PoolSize]));

++++private+static+int+bufferPosition;

++++public+static+int+GetNext()
++++{
++++++++while+(true)
++++++++{
++++++++++++var+result+=+(int)(GetRandomUInt32()+&+int.MaxValue);

++++++++++++if+(result+!=+int.MaxValue)
++++++++++++{
++++++++++++++++return+result;
++++++++++++}
++++++++}
++++}

++++public+static+int+GetNext(int+maxValue)
++++{
++++++++if+(maxValue+<+1)
++++++++{
++++++++++++throw+new+ArgumentException(
++++++++++++++++"Must+be+greater+than+zero.",
++++++++++++++++"maxValue");
++++++++}
++++++++return+GetNext(0,+maxValue);
++++}

++++public+static+int+GetNext(int+minValue,+int+maxValue)
++++{
++++++++const+long+Max+=+1+%2B+(long)uint.MaxValue;

++++++++if+(minValue+>=+maxValue)
++++++++{
++++++++++++throw+new+ArgumentException(
++++++++++++++++"minValue+is+greater+than+or+equal+to+maxValue");
++++++++}

++++++++long+diff+=+maxValue+-+minValue;
++++++++var+limit+=+Max+-+(Max+%25+diff);

++++++++while+(true)
++++++++{
++++++++++++var+rand+=+GetRandomUInt32();
++++++++++++if+(rand+<+limit)
++++++++++++{
++++++++++++++++return+(int)(minValue+%2B+(rand+%25+diff));
++++++++++++}
++++++++}
++++}

++++public+static+void+GetNextBytes(byte[]+buffer)
++++{
++++++++if+(buffer+==+null)
++++++++{
++++++++++++throw+new+ArgumentNullException("buffer");
++++++++}

++++++++if+(buffer.Length+<+PoolSize)
++++++++{
++++++++++++lock+(PositionLock.Value)
++++++++++++{
++++++++++++++++if+((PoolSize+-+bufferPosition)+<+buffer.Length)
++++++++++++++++{
++++++++++++++++++++GeneratePool(Pool.Value);
++++++++++++++++}

++++++++++++++++Buffer.BlockCopy(
++++++++++++++++++++Pool.Value,
++++++++++++++++++++bufferPosition,
++++++++++++++++++++buffer,
++++++++++++++++++++0,
++++++++++++++++++++buffer.Length);
++++++++++++++++bufferPosition+%2B=+buffer.Length;
++++++++++++}
++++++++}
++++++++else
++++++++{
++++++++++++Rng.Value.GetBytes(buffer);
++++++++}
++++}

++++public+static+double+GetNextDouble()
++++{
++++++++return+GetRandomUInt32()+/+(1.0+%2B+uint.MaxValue);
++++}

++++public+override+int+Next()
++++{
++++++++return+GetNext();
++++}

++++public+override+int+Next(int+maxValue)
++++{
++++++++return+GetNext(0,+maxValue);
++++}

++++public+override+int+Next(int+minValue,+int+maxValue)
++++{
++++++++return+GetNext(minValue,+maxValue);
++++}

++++public+override+void+NextBytes(byte[]+buffer)
++++{
++++++++GetNextBytes(buffer);
++++}

++++public+override+double+NextDouble()
++++{
++++++++return+GetNextDouble();
++++}

++++private+static+byte[]+GeneratePool(byte[]+buffer)
++++{
++++++++bufferPosition+=+0;
++++++++Rng.Value.GetBytes(buffer);
++++++++return+buffer;
++++}

++++private+static+uint+GetRandomUInt32()
++++{
++++++++uint+result;
++++++++lock+(PositionLock.Value)
++++++++{
++++++++++++if+((PoolSize+-+bufferPosition)+<+sizeof(uint))
++++++++++++{
++++++++++++++++GeneratePool(Pool.Value)
++++++++++++}

++++++++++++result+=+BitConverter.ToUInt32(
++++++++++++++++Pool.Value,
++++++++++++++++bufferPosition);
++++++++++++bufferPosition%2B=+sizeof(uint);
++++++++}

++++++++return+result;
++++}
}|code-block|syntax|javascript|1007691|entityMap^0|D|6|0|0|1|X|1S|O|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|Z|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

For what its worth, here is a thread-safe, cryptographically strong RNG that inherits <code>Random</code>.

The implementation includes static entry points for ease of use, they have the same names as the public instance methods but are prefixed with "Get".

A call to the <code>RNGCryptoServiceProvider.GetBytes</code> is a relatively expensive operation. This is mitigated through the use of an internal buffer or "Pool" to make less frequent, and more efficient use of <code>RNGCryptoServiceProvider</code>. If there are few generations in an application domain then this could be viewed as overhead.

<pre><code>using System;
using System.Security.Cryptography;

public class SafeRandom : Random
{
 private const int PoolSize = 2048;

 private static readonly Lazy&lt;RandomNumberGenerator&gt; Rng =
 new Lazy&lt;RandomNumberGenerator&gt;(() =&gt; new RNGCryptoServiceProvider());

 private static readonly Lazy&lt;object&gt; PositionLock =
 new Lazy&lt;object&gt;(() =&gt; new object());

 private static readonly Lazy&lt;byte[]&gt; Pool =
 new Lazy&lt;byte[]&gt;(() =&gt; GeneratePool(new byte[PoolSize]));

 private static int bufferPosition;

 public static int GetNext()
 {
 while (true)
 {
 var result = (int)(GetRandomUInt32() &amp; int.MaxValue);

 if (result != int.MaxValue)
 {
 return result;
 }
 }
 }

 public static int GetNext(int maxValue)
 {
 if (maxValue &lt; 1)
 {
 throw new ArgumentException(
 "Must be greater than zero.",
 "maxValue");
 }
 return GetNext(0, maxValue);
 }

 public static int GetNext(int minValue, int maxValue)
 {
 const long Max = 1 + (long)uint.MaxValue;

 if (minValue &gt;= maxValue)
 {
 throw new ArgumentException(
 "minValue is greater than or equal to maxValue");
 }

 long diff = maxValue - minValue;
 var limit = Max - (Max % diff);

 while (true)
 {
 var rand = GetRandomUInt32();
 if (rand &lt; limit)
 {
 return (int)(minValue + (rand % diff));
 }
 }
 }

 public static void GetNextBytes(byte[] buffer)
 {
 if (buffer == null)
 {
 throw new ArgumentNullException("buffer");
 }

 if (buffer.Length &lt; PoolSize)
 {
 lock (PositionLock.Value)
 {
 if ((PoolSize - bufferPosition) &lt; buffer.Length)
 {
 GeneratePool(Pool.Value);
 }

 Buffer.BlockCopy(
 Pool.Value,
 bufferPosition,
 buffer,
 0,
 buffer.Length);
 bufferPosition += buffer.Length;
 }
 }
 else
 {
 Rng.Value.GetBytes(buffer);
 }
 }

 public static double GetNextDouble()
 {
 return GetRandomUInt32() / (1.0 + uint.MaxValue);
 }

 public override int Next()
 {
 return GetNext();
 }

 public override int Next(int maxValue)
 {
 return GetNext(0, maxValue);
 }

 public override int Next(int minValue, int maxValue)
 {
 return GetNext(minValue, maxValue);
 }

 public override void NextBytes(byte[] buffer)
 {
 GetNextBytes(buffer);
 }

 public override double NextDouble()
 {
 return GetNextDouble();
 }

 private static byte[] GeneratePool(byte[] buffer)
 {
 bufferPosition = 0;
 Rng.Value.GetBytes(buffer);
 return buffer;
 }

 private static uint GetRandomUInt32()
 {
 uint result;
 lock (PositionLock.Value)
 {
 if ((PoolSize - bufferPosition) &lt; sizeof(uint))
 {
 GeneratePool(Pool.Value)
 }

 result = BitConverter.ToUInt32(
 Pool.Value,
 bufferPosition);
 bufferPosition+= sizeof(uint);
 }

 return result;
 }
}
</code></pre>

blocks|key|1007870|text|因为Random不是线程安全的，所以每个线程都应该有一个，而不是全局实例。如果您担心这些多个Random类同时被播种(即通过DateTime.Now.Ticks或类似的方式)，您可以使用Guids来播种每个类。.NET+Guid生成器花了相当长的时间来确保不可重复的结果，因此：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1007871|var+rnd+=+new+Random(BitConverter.ToInt32(Guid.NewGuid().ToByteArray(),+0))|code-block|syntax|javascript|1007872|entityMap^0|2|6|1A|6|1Q|I|2L|4|32|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|L|$]]

Since <code>Random</code> isn't thread-safe, you should have one per thread, rather than a global instance. If you're worried about these multiple <code>Random</code> classes being seeded at the same time (i.e. by <code>DateTime.Now.Ticks</code> or such), you can use <code>Guid</code>s to seed each of them. The .NET <code>Guid</code> generator goes to considerable lengths to ensure non-repeatable results, hence:

<pre><code>var rnd = new Random(BitConverter.ToInt32(Guid.NewGuid().ToByteArray(), 0))
</code></pre>

blocks|key|1222325|text|用ThreadLocal重新实现BlueRaja的回答|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1222326|public+static+class+ThreadSafeRandom
{
++++private+static+readonly+System.Random+GlobalRandom+=+new+Random();
++++private+static+readonly+ThreadLocal<Random>+LocalRandom+=+new+ThreadLocal<Random>(()+=>+
++++{
++++++++lock+(GlobalRandom)
++++++++{
++++++++++++return+new+Random(GlobalRandom.Next());
++++++++}
++++});

++++public+static+int+Next(int+min+=+0,+int+max+=+Int32.MaxValue)
++++{
++++++++return+LocalRandom.Value.Next(min,+max);
++++}
}|code-block|syntax|javascript|1222327|entityMap^0|1|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Reimplementation of BlueRaja's answer using <code>ThreadLocal</code>:

<pre><code>public static class ThreadSafeRandom
{
 private static readonly System.Random GlobalRandom = new Random();
 private static readonly ThreadLocal&lt;Random&gt; LocalRandom = new ThreadLocal&lt;Random&gt;(() =&gt; 
 {
 lock (GlobalRandom)
 {
 return new Random(GlobalRandom.Next());
 }
 });

 public static int Next(int min = 0, int max = Int32.MaxValue)
 {
 return LocalRandom.Value.Next(min, max);
 }
}
</code></pre>

blocks|key|1222399|text|这里有一个简单的解决方案，不需要创建类。隐藏ad-hoc+lambda中的所有内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1222400|private+static+Func<int,+int,+int>+GetRandomFunc()
{
++++Random+random+=+new+Random();
++++object+lockObject+=+new+object();

++++return+(min,+max)+=>
++++{
++++++++lock+(lockObject)
++++++++{
++++++++++++return+random.Next(min,+max);
++++++++}
++++};
}|code-block|syntax|javascript|1222401|在任何需要线程安全随机生成器类中，定义|1222402|private+static+readonly+Func<int,+int,+int>+GetRandomNext+=+GetRandomFunc();|1222403|然后在你的类中自由使用它：|1222404|int+nextRandomValue+=+GetRandomNext(0,+10);|1222405|根据需要，radndom函数可以具有不同的签名。例如：|1222406|private+static+Func<int>+GetRandomFunc()
{
++++Random+random+=+new+Random();
++++object+lockObject+=+new+object();

++++return+()+=>
++++{
++++++++lock+(lockObject)
++++++++{
++++++++++++return+random.Next();
++++++++}
++++};
}|1222407|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Here is a simple solution that doesn't involve creating classes. Hides everything inside an ad-hoc lambda:
<pre><code>private static Func&lt;int, int, int&gt; GetRandomFunc()
{
 Random random = new Random();
 object lockObject = new object();

 return (min, max) =&gt;
 {
 lock (lockObject)
 {
 return random.Next(min, max);
 }
 };
}
</code></pre>
In any class that needs a thread safe random generator define
<pre><code>private static readonly Func&lt;int, int, int&gt; GetRandomNext = GetRandomFunc();
</code></pre>
Then use it freely inside your class:
<pre><code>int nextRandomValue = GetRandomNext(0, 10);
</code></pre>
The radndom function can have different signatures depending what is needed. e.g.
<pre><code>private static Func&lt;int&gt; GetRandomFunc()
{
 Random random = new Random();
 object lockObject = new object();

 return () =&gt;
 {
 lock (lockObject)
 {
 return random.Next();
 }
 };
}
</code></pre>

blocks|key|1222474|text|我只是同时在大量线程上创建了Random实例，并从结果中获得了意想不到的模式，因为假设所有的种子都是相同的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1222475|我的解决方案是创建一个线程安全类-|1222476|++public+class+StaticRandom
++++{
++++++++static+Random+rnd+=+new+Random();

++++++++public+static+int+GetNext()
++++++++{
++++++++++++//+random+is+not+properly+thread+safe
++++++++++++lock(rnd)
++++++++++++{
++++++++++++++++return+rnd.Next();
++++++++++++}
++++++++}
++++}|code-block|syntax|javascript|1222477|然后，为每个线程创建一个新的Random对象实例-|1222478|//+Take+this+threads+instance+seed+from+the+static+global+version
Random+rnd+=+new+Random(StaticRandom.GetNext());|1222479|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I just created Random instance on a load of threads simultaneously and got unexpected patterns from the results because, presumably, all the seeds were the same.
My solution was to create a thread safe class -
<pre><code> public class StaticRandom
 {
 static Random rnd = new Random();

 public static int GetNext()
 {
 // random is not properly thread safe
 lock(rnd)
 {
 return rnd.Next();
 }
 }
 }
</code></pre>
And then, create a new Random object instance for each thread -
<pre><code>// Take this threads instance seed from the static global version
Random rnd = new Random(StaticRandom.GetNext());
</code></pre>

blocks|key|1007615|text|更新:它不是。在调用.Next()方法时，您需要在每次连续的调用中重用一个随机实例，并锁定某个“信号量”对象，或者在每次调用中使用一个具有保证的随机种子的新实例。您可以按照Yassir的建议，通过在.NET中使用密码术来获得有保证的不同种子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1007616|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

UPDATED: It is not. You need to either reuse an instance of Random on each consecutive call with locking some "semaphore" object while calling the .Next() method or use a new instance with a guaranteed random seed on each such call. You can get the guaranteed different seed by using cryptography in .NET as Yassir suggested.

blocks|key|1222181|text|通过对种子使用无锁算法，可以对传统的thread+local+storage+approach进行改进。下面的代码被无耻地从Java的算法中窃取(甚至可能是improving+)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1222182|public+static+class+RandomGen2+
{
++++private+static+readonly+ThreadLocal<Random>+_rng+=+
+++++++++++++++++++++++new+ThreadLocal<Random>(()+=>+new+Random(GetUniqueSeed()));

++++public+static+int+Next()+
++++{+
++++++++return+_rng.Value.Next();+
++++}+

++++private+const+long+SeedFactor+=+1181783497276652981L;
++++private+static+long+_seed+=+8682522807148012L;

++++public+static+int+GetUniqueSeed()
++++{
++++++++long+next,+current;
++++++++do
++++++++{
++++++++++++current+=+Interlocked.Read(ref+_seed);
++++++++++++next+=+current+*+SeedFactor;
++++++++}+while+(Interlocked.CompareExchange(ref+_seed,+next,+current)+!=+current);
++++++++return+(int)next+%5E+Environment.TickCount;
+++}+
}|code-block|syntax|javascript|1222183|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/b/pfxteam/archive/2009/02/19/9434171.aspx|1|https://stackoverflow.com/questions/18092160/whats-with-181783497276652981-and-8682522807148012-in-random-java-7^0|I|T|0|26|9|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

The traditional <a href="http://blogs.msdn.com/b/pfxteam/archive/2009/02/19/9434171.aspx" rel="nofollow noreferrer">thread local storage approach</a> can be improved upon by using a lock-less algorithm for the seed. The following was shamelessly stolen from Java's algorithm (possibly even <a href="https://stackoverflow.com/questions/18092160/whats-with-181783497276652981-and-8682522807148012-in-random-java-7">improving</a> on it):

<pre><code>public static class RandomGen2 
{
 private static readonly ThreadLocal&lt;Random&gt; _rng = 
 new ThreadLocal&lt;Random&gt;(() =&gt; new Random(GetUniqueSeed()));

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

 private const long SeedFactor = 1181783497276652981L;
 private static long _seed = 8682522807148012L;

 public static int GetUniqueSeed()
 {
 long next, current;
 do
 {
 current = Interlocked.Read(ref _seed);
 next = current * SeedFactor;
 } while (Interlocked.CompareExchange(ref _seed, next, current) != current);
 return (int)next ^ Environment.TickCount;
 } 
}
</code></pre>

Is C#'s <a href="https://docs.microsoft.com/en-us/dotnet/api/system.random.next#overloads" rel="noreferrer"><code>Random.Next()</code></a> method thread safe?

问C#随机数生成器线程安全吗？
EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#随机数生成器线程安全吗？EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#随机数生成器线程安全吗？
EN