我有以下功能:
//Function to get random number
public static int RandomNumber(int min, int max)
{
Random random = new Random();
return random.Next(min, max);
}
我怎么称呼它:
byte[] mac = new byte[6];
for (int x = 0; x < 6; ++x)
mac[x] = (byte)(Misc.RandomNumber((int)0xFFFF, (int)0xFFFFFF) % 256);
如果我在运行时使用调试器执行该循环,我会得到不同的值(这是我想要的)。但是,如果我在该代码下方两行放置一个断点,则 mac
数组的所有成员都具有相同的值。
为什么会这样?
new Random().Next((int)0xFFFF, (int)0xFFFFFF) % 256);
不会产生比 .Next(0, 256)
更好的“随机”数字
Rand.Next(int, int)
方法,该方法提供对随机值的静态访问,而不会锁定或遇到种子重用问题
每次执行 new Random()
时,都会使用时钟对其进行初始化。这意味着在一个紧密的循环中,您可以多次获得相同的值。您应该保留一个 Random 实例并继续在 same 实例上使用 Next。
//Function to get a random number
private static readonly Random random = new Random();
private static readonly object syncLock = new object();
public static int RandomNumber(int min, int max)
{
lock(syncLock) { // synchronize
return random.Next(min, max);
}
}
编辑(见评论):为什么我们需要一个lock
?
基本上,Next
将更改 Random
实例的内部状态。如果我们同时从多个线程执行此操作,您可能会争辩说“我们只是让结果变得更加随机”,但我们实际上所做的可能是破坏内部实现,我们也可以开始从不同的线程获取相同的数字,这可能是一个问题 - 也可能不是。但是,内部发生的事情的保证是更大的问题。因为 Random
确实不保证线程安全。因此,有两种有效的方法:
同步,这样我们就不会从不同的线程同时访问它
每个线程使用不同的随机实例
两者都可以;但是同时从多个调用者中对单个实例进行互斥只是自找麻烦。
lock
实现了这些方法中的第一个(也是更简单的);但是,另一种方法可能是:
private static readonly ThreadLocal<Random> appRandom
= new ThreadLocal<Random>(() => new Random());
这是每个线程,所以你不需要同步。
为了便于在整个应用程序中重用,静态类可能会有所帮助。
public static class StaticRandom
{
private static int seed;
private static ThreadLocal<Random> threadLocal = new ThreadLocal<Random>
(() => new Random(Interlocked.Increment(ref seed)));
static StaticRandom()
{
seed = Environment.TickCount;
}
public static Random Instance { get { return threadLocal.Value; } }
}
然后您可以使用带有代码的静态随机实例,例如
StaticRandom.Instance.Next(1, 100);
Mark 的解决方案可能非常昂贵,因为它每次都需要同步。
我们可以通过使用线程特定的存储模式来解决同步的需要:
public class RandomNumber : IRandomNumber
{
private static readonly Random Global = new Random();
[ThreadStatic] private static Random _local;
public int Next(int max)
{
var localBuffer = _local;
if (localBuffer == null)
{
int seed;
lock(Global) seed = Global.Next();
localBuffer = new Random(seed);
_local = localBuffer;
}
return localBuffer.Next(max);
}
}
测量这两种实现,您应该会看到显着的差异。
_local
是 ThreadStatic
,为什么要将它复制到 var localBuffer
或从 var localBuffer
复制?这是性能优化吗?也就是说,访问 ThreadStatic
变量的性能是否比访问常规变量的成本要高得多? (如果是这样,在典型情况下,这可能会使所谓的优于 lock
的优势无效。如果不是,则可以简化代码。)
我在 here 中的回答:
只是重申正确的解决方案:
namespace mySpace
{
public static class Util
{
private static rnd = new Random();
public static int GetRandom()
{
return rnd.Next();
}
}
}
所以你可以打电话:
var i = Util.GetRandom();
自始至终。
如果您严格需要真正的无状态静态方法来生成随机数,您可以依赖 Guid
。
public static class Util
{
public static int GetRandom()
{
return Guid.NewGuid().GetHashCode();
}
}
它会慢一点,但可能比 Random.Next
随机得多,至少从我的经验来看是这样。
但不是:
new Random(Guid.NewGuid().GetHashCode()).Next();
不必要的对象创建会使其变慢,尤其是在循环下。
永不:
new Random().Next();
它不仅速度较慢(在循环内),而且它的随机性......在我看来并不是很好......
Random
类与案例 2 匹配(因此也是案例 1)。如果您 not 在案例 2 中,您只能用您的 Guid+Hash
替换 Random
的用法。案例 1 可能足以回答问题,然后,您的 Guid+Hash
工作正常。但是没有说清楚(ps:this uniform)
Random
和 Guid.NewGuid().GetHashCode()
,并且两者都是随机的。 new Random(Guid.NewGuid().GetHashCode())
和使用同步的“master”Random
为“child”Random
生成种子一样有效。当然,这取决于您的系统如何生成 Guid - 对于我的系统,它们是相当随机的,而在其他情况下,它甚至可能是加密随机的。所以现在 Windows 或 MS SQL 似乎还不错。不过,单声道和/或移动设备可能会有所不同。
GetHashCode
是从其字符串表示派生的。根据我的喜好,输出是非常随机的。
我宁愿使用以下类来生成随机数:
byte[] random;
System.Security.Cryptography.RNGCryptoServiceProvider prov = new System.Security.Cryptography.RNGCryptoServiceProvider();
prov.GetBytes(random);
public static int Next(int min, int max) ...
。但是为了性能,修改他的代码以将 new
移出 Next
方法 - 请参阅我的评论。
1)正如 Marc Gravell 所说,尝试使用一个随机发生器。将它添加到构造函数中总是很酷:System.Environment.TickCount。
2) 一个小费。假设您要创建 100 个对象,并假设每个对象都应该有自己的随机生成器(如果您在很短的时间内计算随机数的 LOADS 会很方便)。如果您要在循环中执行此操作(生成 100 个对象),您可以这样做(以确保完全随机):
int inMyRandSeed;
for(int i=0;i<100;i++)
{
inMyRandSeed = System.Environment.TickCount + i;
.
.
.
myNewObject = new MyNewObject(inMyRandSeed);
.
.
.
}
// Usage: Random m_rndGen = new Random(inMyRandSeed);
干杯。
Random()
构造函数调用 Random(Environment.TickCount)
Random()
构造函数两次,您将获得两个随机生成器,每个生成器生成完全相同的随机数序列。可能不是你想要的!上述逻辑 (#2) 使用种子 TickCount+0
、TickCount+1
等 - 所以生成器都是不同的。
每次执行
Random random = new Random (15);
执行数百万次都没关系,您将始终使用相同的种子。
如果你使用
Random random = new Random ();
你得到不同的随机数序列,如果黑客猜到了种子并且你的算法与你系统的安全性有关——你的算法被破坏了。我执行 mult。在此构造函数中,种子由系统时钟指定,如果在很短的时间(毫秒)内创建了多个实例,则它们可能具有相同的种子。
如果您需要安全的随机数,则必须使用该类
System.Security.Cryptography.RNGCryptoServiceProvider
public static int Next(int min, int max)
{
if(min >= max)
{
throw new ArgumentException("Min value is greater or equals than Max value.");
}
byte[] intBytes = new byte[4];
using(RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
{
rng.GetNonZeroBytes(intBytes);
}
return min + Math.Abs(BitConverter.ToInt32(intBytes, 0)) % (max - min + 1);
}
用法:
int randomNumber = Next(1,100);
It does not matter if you execute it millions of times, you will always use the same seed.
除非您自己指定种子,否则这是不正确的。
Next
上调用 new RNGCryptoServiceProvider()
是多余的。相反,声明 private static RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
然后删除 using
包装器;只需在该静态上调用 rng.GetNonZeroBytes(intBytes);
即可。
你可以使用这样的代码:
public static 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;
}
此代码可以按原样使用,也可以通过 NuGet 包 ThreadSafeRandomizer 使用。
我用这个:
int randomNumber = int.Parse(Guid.NewGuid().ToString().FirstOrDefault(Char.IsDigit).ToString().Replace("\0", "0"));
性能:在我的 PC 上生成 100 万个随机数:711 毫秒。
如果 Guid 不包含任何数字(我不知道这是否可能),那么将使用 0 作为结果。
有很多解决方案,这里有一个:如果你只想数字擦除字母并且方法接收随机和结果长度。
public String GenerateRandom(Random oRandom, int iLongitudPin)
{
String sCharacters = "123456789ABCDEFGHIJKLMNPQRSTUVWXYZ123456789";
int iLength = sCharacters.Length;
char cCharacter;
int iLongitudNuevaCadena = iLongitudPin;
String sRandomResult = "";
for (int i = 0; i < iLongitudNuevaCadena; i++)
{
cCharacter = sCharacters[oRandom.Next(iLength)];
sRandomResult += cCharacter.ToString();
}
return (sRandomResult);
}
Random
实例,但您仍然希望调用者创建一个共享实例。如果调用者每次都创建一个新实例,并且代码在时钟更改之前执行两次,您将获得相同的随机数。所以这个答案仍然做出可能是错误的假设。
我通过使用 Rnd() 函数解决了这个问题:
Function RollD6() As UInteger
RollD6 = (Math.Floor(6 * Rnd())) + 1
Return RollD6
End Function
当表单加载时,我使用 Randomize() 方法来确保每次运行时我不会总是得到相同的随机数序列。
在 Visual Basic 中这是可行的(可能可以转换为 C#,如果不是 DLL 引用可以是一个解决方案):
Private Function GetRandomInt(ByVal Min As Integer, ByVal Max As Integer) As Integer
Static Generator As System.Random = New System.Random()
Return Generator.Next(Min, Max)
End Function
总是得到一个正的随机数。
var nexnumber = Guid.NewGuid().GetHashCode();
if (nexnumber < 0)
{
nexnumber *= -1;
}
不定期副业成功案例分享
lock(random)
?random.Next()
调用也在lock (syncObject)
内时,lock (syncObject)
才会有所帮助。如果您描述的场景即使在正确使用lock
的情况下确实发生,它也极可能发生在单线程场景中(例如Random
被巧妙地破坏)。