C＃随机数生成器线程安全吗？

Question

是c＃'s rando> rando> rando> randy.next（） 方法线程安全吗？

Answer 1

有关线程安全的随机数生成器，请查看。从文档中：

线程安全

这种类型是线程安全的。

Answer 2

我刚刚在螺纹上同时创建了随机实例，并从结果中获得了意外的模式，因为大概所有种子都是相同的。

我的解决方案是创建一个线程安全类 -

  public class StaticRandom
    {
        static Random rnd = new Random();

        public static int GetNext()
        {
            // random is not properly thread safe
            lock(rnd)
            {
                return rnd.Next();
            }
        }
    }

然后，为每个线程创建一个新的随机对象实例 -

// Take this threads instance seed from the static global version
Random rnd = new Random(StaticRandom.GetNext());

Answer 3

这是使用threadlocal的有效解决方案：

public class ThreadSafeRandom
{
    private static readonly Random _global = new Random();
    private static readonly ThreadLocal<Random> _local = new ThreadLocal<Random>(() =>
    {
        int seed;
        lock (_global)
        {
            seed = _global.Next();
        }
        return new Random(seed);
    });

    public static Random Instance => _local.Value;
}

要使用，替换：

var random = new Random();
var myNum = random.Next();

与：

var myNum = ThreadSafeRandom.Instance.Next();

此解决方案已包装为 nuget软件包在

编辑：自.NET 6.0以来，您可以使用randy.shared.next（）而不是使用。您仍然可以使用上述软件包，该软件包在上面的代码或随机中使用预处理器指令。

Answer 4

这是 blueraja的答案作为静态课程的静态类，并实现了所有公共随机成员。

/// <summary>
/// A pseudo-random number generator based on <see cref="Random"/>, but with the following enhancements:
/// <list type="number">
/// <item>Can be safely used from any thread without defaulting to 0.</item>
/// <item>Repeated calls from different threads do not tend to generate identical sequences.</item>
/// </list>
/// </summary>
public static class ThreadSafeRandom
{
    private static readonly Random _globalSeeder = new Random();

    /// <summary>
    /// Holds a separate <see cref="Random"/> instance for each thread.
    /// </summary>
    [ThreadStatic] private static Random _threadStaticInstance;

    /// <summary>
    /// Seeds each thread's <see cref="_threadStaticInstance"/> with <see cref="_globalSeeder"/>'s <see cref="Random.Next()"/>.
    /// Simply using <see langword="new"/> <see cref="Random()"/> would cause a problem where,
    /// if multiple threads' <see cref="Random"/> instances were constructed very close in time,
    /// they would end up with the same seed, and therefore identical sequences.
    /// </summary>
    private static Random GetThreadStaticInstance()
    {
        if (_threadStaticInstance == null)
        {
            int seed;
            lock (_globalSeeder)
            {
                seed = _globalSeeder.Next();
            }

            _threadStaticInstance = new Random(seed);
        }

        return _threadStaticInstance;
    }

    /// <inheritdoc cref="Random.Next()"/>
    public static int Next() => GetThreadStaticInstance().Next();

    /// <inheritdoc cref="Random.Next(int, int)"/>
    public static int Next(int minValue, int maxValue) => GetThreadStaticInstance().Next(minValue, maxValue);

    /// <inheritdoc cref="Random.Next(int)"/>
    public static int Next(int maxValue) => GetThreadStaticInstance().Next(maxValue);

    /// <inheritdoc cref="Random.NextDouble()"/>
    public static double NextDouble() => GetThreadStaticInstance().NextDouble();

    /// <inheritdoc cref="Random.NextBytes(byte[])"/>
    public static void NextBytes(byte[] buffer) => GetThreadStaticInstance().NextBytes(buffer);

Answer 5

更新：不是。您需要在调用.next（）方法时锁定某些“信号量”对象的每个连续调用的随机实例，或者在每个呼叫上使用具有保证随机种子的新实例。如Yassir所建议，您可以通过在.NET中使用密码学来获得保证的不同种子。

Answer 6

传统 thread nore noreferrer“> thread thread local Storage方法可以是通过对种子使用无锁算法来改进。以下是从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;
   } 
}

Answer 7

不，使用来自多个线程的同一实例会导致其破裂并返回所有0。但是，创建线程安全版本（无需在每个调用next（））的无需讨厌的锁。改编自本文：

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

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

        return _local.Next();
    }
}

这个想法是为每个线程保留一个单独的static Random变量。但是，以明显的方式执行此操作会失败，因为Random的另一个问题 - 如果在几乎同一时间创建了多个实例（在约15ms之内），它们将全部返回相同的值！为了解决此问题，我们创建一个全球静态随机实例，以生成每个线程使用的种子。

顺便说一句，上面的文章具有随机的这两个问题的代码。

Answer 8

下一个方法可以实现线程安全性。但是，这是一种实例方法。如果您不在不同线程上共享随机的实例，则不必担心一个实例中的状态腐败。请勿在不同的线程上使用随机的单个实例，而不会持有某种独有的锁定。

乔恩·斯基特（Jon Skeet）在此主题上有几个不错的帖子：

staticrandom staticrandom 一个>
重新审视随机性

正如某些评论员所指出的使用随机的不同实例，这些实例是线程排名，但被播种相同，因此会诱导伪数字的相同序列，因为它们可以同时或在彼此之间紧密的时间近处创建。减轻该问题的一种方法是使用主随机实例（由单个线程锁定）来生成一些随机种子并初始化新的随机>随机其他每个线程的实例使用。

Answer 9

微软的官方答案是非常 strong no 。来自 http://msdn.microsoft.com/en-en-us/en-en-us/ library/system.random.aspx＃8 ：

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

如DOC中所述由多个线程使用：它只是停止工作。

（即，有一个种族条件，当触发时，从“ andural.next ....”的返回值对于所有后续调用的方法为0。）

Answer 10

C＃的Random.next（）方法线程安全？

如前所述，Anwer是 no 。但是，从 .net6 开始，我们有盒子线程安全替代方案：randy.shared.next（）;

请参阅此处的详细信息。

Answer 11

不，这不是线程的安全。如果您需要使用不同线程的相同实例，则必须同步使用情况。

不过，我真的看不到您需要的原因。每个线程具有自己的随机类实例将更加有效。

Answer 12

另一种安全方法是使用threadlocal＆lt; t＆gt;如下：

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

generateSeed（）方法将需要每次调用唯一值以确保随机返回一个唯一值每个线程中的数字序列都是唯一的。

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

将适用于少量线程。

Answer 13

更新从.net 6 在窗帘后面进行同步）。

使用threadlocal：

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

Answer 14

就其价值而言，这里是继承Random的线程安全性强的RNG。

该实现包括静态输入点，易于使用，它们的名称与公共实例方法相同，但前缀为“ 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;
    }
}

Answer 15

由于随机不是线程安全，因此您应该每个线程一个，而不是全局实例。如果您担心这些多个随机同时播种的类（即dateTime.now.ticks之类的），则可以使用guid < /code> s播种每个。 .NET GUID生成器的长度相当长以确保不可重复的结果，因此：

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

Answer 16

每个文档

这种类型的任何公共静态（在Visual Basic中共享）都是线程安全的。任何实例成员都不能保证是线程安全的。

http://msdn.microsoft.com/en-en-us/library/ system.random.aspx

Answer 17

这是一个简单的解决方案，不涉及创建类。隐藏了临时Lambda中的所有内容：

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

在需要线程安全的随机生成器定义的任何类中

private static readonly Func<int, int, int> GetRandomNext = GetRandomFunc();

，然后在类中自由使用：

int nextRandomValue = GetRandomNext(0, 10);

Radndom函数可以根据所需的内容具有不同的签名。例如

private static Func<int> GetRandomFunc()
{
    Random random = new Random();
    object lockObject = new object();

    return () =>
    {
        lock (lockObject)
        {
            return random.Next();
        }
    };
}