C＃的Random.Next()方法线程安全吗？

在Next实现线程安全性的方法中，没有做任何特殊的事情。但是，这是一个实例方法。如果您不共享Random不同线程之间的实例，则不必担心实例内的状态损坏。在未Random持有某种排他锁的情况下，请勿在不同线程中使用单个实例。

乔恩·斯基特（Jon Skeet）在此主题上有几篇不错的文章：

StaticRandom
重访随机性

正如一些评论员所指出的那样，在使用不同实例时存在另一个潜在问题，这些实例Random是线程独占的，但它们的种子是相同的，因此会产生相同的伪随机数序列，因为它们可能同时创建或在短时间内创建彼此接近。缓解该问题的一种方法是使用主Random实例（由单个线程锁定）来生成一些随机种子，并初始化Random要使用的其他每个线程的新实例。

不可以，在多个线程中使用同一实例可能会导致它中断并返回全0。但是，创建线程安全版本（无需在每次调用时都设置讨厌的锁Next()）非常简单。改编自本文的想法：

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

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

        return _local.Next();
    }
}

这个想法是static Random为每个线程保留一个单独的变量。但是，由于存在另一个问题Random-如果几乎同时（在大约15ms内）创建多个实例，则这样做显然会失败，它们都将返回相同的值！为了解决这个问题，我们创建了一个全局静态Random实例来生成每个线程使用的种子。

顺便说一下，以上文章的代码演示了的这两个问题Random。

从微软的官方答案是非常强的没有。从http://msdn.microsoft.com/en-us/library/system.random.aspx#8：

随机对象不是线程安全的。如果您的应用程序从多个线程调用随机方法，则必须使用同步对象来确保一次只有一个线程可以访问随机数生成器。如果不确保以线程安全的方式访问Random对象，则对返回随机数的方法的调用将返回0。

如文档中所述，当多个线程使用同一个Random对象时，会发生非常讨厌的副作用：它只是停止工作。

（即，存在一种竞争条件，当触发该竞争条件时，所有后续调用的“ random.Next ....”方法的返回值将为0。）

不，这不是线程安全的。如果需要使用来自不同线程的同一实例，则必须同步使用。

不过，我真的看不到您为什么需要它的任何原因。每个线程拥有自己的Random类实例将更加高效。

另一种线程安全的方法是使用ThreadLocal<T>如下：

new ThreadLocal<Random>(() => new Random(GenerateSeed()));

GenerateSeed()每次调用该方法时，都需要返回一个唯一值，以确保随机数序列在每个线程中都是唯一的。

static int SeedCount = 0;
static int GenerateSeed() { 
    return (int) ((DateTime.Now.Ticks << 4) + 
                   (Interlocked.Increment(ref SeedCount))); 
}

将适用于少量线程。

由于Random不是线程安全的，因此每个线程应该有一个，而不是全局实例。如果您担心Random同时播种这些多个类（即，按DateTime.Now.Ticks此类），则可以使用Guids为它们中的每一个播种。.NETGuid生成器会花费相当长的时间来确保不可重复的结果，因此：

var rnd = new Random(BitConverter.ToInt32(Guid.NewGuid().ToByteArray(), 0))

对于它的价值，这里有一个继承自线程安全，具有加密功能的RNG Random。

该实现包括易于使用的静态入口点，它们具有与公共实例方法相同的名称，但前缀为“ Get”。

调用RNGCryptoServiceProvider.GetBytes是相对昂贵的操作。通过使用内部缓冲区或“池”可以减少使用频率和效率，从而缓解这种情况RNGCryptoServiceProvider。如果应用程序域中的代数很少，那么这可以视为开销。

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 + (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 % diff);

        while (true)
        {
            var rand = GetRandomUInt32();
            if (rand < limit)
            {
                return (int)(minValue + (rand % 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 += 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) < sizeof(uint))
            {
                GeneratePool(Pool.Value)
            }

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

        return result;
    }
}

每个文档

此类型的任何公共static（在Visual Basic中为Shared）成员都是线程安全的。不保证任何实例成员都是线程安全的。

http://msdn.microsoft.com/zh-CN/library/system.random.aspx

使用ThreadLocal以下命令重新实现BlueRaja的答案：

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

对于线程安全的随机数生成器，请查看RNGCryptoServiceProvider。从文档：

线程安全

此类型是线程安全的。

更新：不是。您需要在每次调用.Next（）方法时锁定一些“信号量”对象，或者在每次连续调用中重用Random实例，或者在每次此类调用中使用带有保证随机种子的新实例。您可以按照Yassir的建议通过在.NET中使用加密来获得有保证的其他种子。

传统的 通过对种子使用无锁算法，可以改进线程本地存储方法。从Java的算法中偷偷偷走了以下内容（甚至可能对其进行了改进）：

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 ^ Environment.TickCount;
   } 
}