Random Class

This article  http://blog.codeeffects.com/Article/Generate-Random-Numbers-And-Strings-C-Sharp  contains a simple solution of how to generate a different seed for the Random c-tor at any time. That makes possible to create a new local instance of Random on each call. And that eliminates the need for a global instance of Random and for locks of "semaphore" objects. Hope this helps.

There is a very nasty side effect that can happen when the same Random object is used by multiple threads: it just stops working (i.e. there is a race condition which when triggered, the return value from the 'random.Next....' methods will be 0 (for all subsequent calls))

This means that one has to be careful when using the Random Class.

Here are two blog posts with more details, comments and code samples on this topic:

• Another issue with the .NET Random class (http://diniscruz.blogspot.com/2011/07/another-issue-with-net-random-class.html)
• Humm … .NET Random class is not Thread Safe? (http://o2platform.wordpress.com/2011/07/16/humm-net-random-class-is-not-thread-safe/)

The Random Class and Thread Safety

This lack of thread safety is documented in the Thread Safety section of this topic. For more information about how to call Random instance methods safely from multiple threads, see the "Random Instance Methods and Thread Safety" section of the following post.

--Ron Petrusha
Common Language Runtime User Education
Microsoft Corporation

Although the documentation says "Any instance members are not guaranteed to be thread safe.", the failure case of using a single Random instance from multiple threads is severe enough that I think it deserves special mention.

If the Random class is accessed from multiple threads at the same time, the random number generator will break, and Random.Next() will return all zeros, forever. If you're doing anything with multiple threads, be very sure that you're not accessing a single Random object simultaneously from multiple threads

Random Instance Methods and Thread Safety

This limitation, as you point out, is already documented in the Thread Safety section of this topic. If the members of a type are not guaranteed to be thread-safe, simultaneous or near-simultaneous calls to the members of an instance of the type created on one thread from other threads are likely to produce unexpected or erroneous results. And as you also point out, developers should ""be very sure that you're not accessing a single Random object simultaneously from multiple threads". It's important to emphasize, though, that this does not mean that calls to instance methods that are not thread-safe should not be made from multiple threads. Instead, you can safely call instance methods from multiple threads as long as you ensure that only a single thread can make the call at any particular time. There are a variety of ways to do this by using the synchronization types in the System.Threading namespace, or by using language constructs such as lock in C# and SyncLock in Visual Basic.

For example, the following example illustrates the problem. A main thread and ten additional threads each try to retrieve two million random numbers. A relatively small number of the potential twelve million calls are executed before the random number generator fails.

using System;
using System.Threading;
public class Example
{
   [ThreadStatic] static double previous = 0.0;
   [ThreadStatic] static bool abnormal;
   [ThreadStatic] static int perThreadCtr = 0;

   Random rand;

   public Example()
   { 
      rand = new Random();
   } 
   public static void Main()
   {
      Example ex = new Example();
      Thread.CurrentThread.Name = "Main";
      ex.Execute();
      Console.WriteLine("Program execution concluded...");
   }
   private void Execute()
   {   
      for (int threads = 1; threads <= 10; threads++)
      {
         Thread newThread = new Thread(new ThreadStart(this.GetRandomNumbers));
         newThread.Name = threads.ToString();
         newThread.Start();
      }
      this.GetRandomNumbers();
   }
   private void GetRandomNumbers()
   {
       double result = 0.0;

         for (int ctr = 0; ctr < 2000000; ctr++)
         {
            result = rand.NextDouble();
            if (result == previous) {
               abnormal = true;
               break;
            }
            else {
               previous = result;
            }
            perThreadCtr++;   
         }

       // get last result
      if (abnormal)
         Console.WriteLine("Result is {0} in Thread {1}", previous, Thread.CurrentThread.Name);

      Console.WriteLine("Thread {0} finished execution of {1:N0} iterations.", 
                        Thread.CurrentThread.Name, perThreadCtr);        
   }
}

By using the C# lock statement, as in the following example, we can ensure the thread safety of our application, and also ensure that each thread retrieves two million random numbers.

using System;
using System.Threading;

public class Example
{
   [ThreadStatic] static double previous = 0.0;
   [ThreadStatic] static bool abnormal;
   [ThreadStatic] static int perThreadCtr = 0;
   [ThreadStatic] static int ctr = 0;

   private static Object lockObj;
   Random rand;

   public Example()
   { 
      rand = new Random();
      lockObj = new Object();
   } 
   public static void Main()
   {
      Example ex = new Example();
      Thread.CurrentThread.Name = "Main";
      ex.Execute();
      Console.WriteLine("Program execution concluded...");
   }
   private void Execute()
   {   
      for (int threads = 1; threads <= 10; threads++)
      {
         Thread newThread = new Thread(new ThreadStart(this.GetRandomNumbers));
         newThread.Name = threads.ToString();
         newThread.Start();
      }
      this.GetRandomNumbers();
   }
   private void GetRandomNumbers()
   {
      double result = 0.0;


         for (ctr = 0; ctr < 2000000; ctr++)
         {
            lock (lockObj) {
            result = rand.NextDouble();
            }
            if (result == previous) {
               abnormal = true;
               break;
            }
            else {
               previous = result;
            }
            perThreadCtr++;   
         }
      // get last result
      if (abnormal)
         Console.WriteLine("Result is {0} in Thread {1}", previous, Thread.CurrentThread.Name);

      Console.WriteLine("Thread {0} finished execution of {1:N0} iterations.", 
                        Thread.CurrentThread.Name, perThreadCtr);        
   }
}

--Ron Petrusha
Common Language Runtime User Education
Microsoft Corporation

I have created a windows application and had taken a label to show the display. In the form load I have written the code below. When I debug I get random numbers but when I run without debug the same number repeats over and again. Why this happens? Seems to be a bug?

StringBuilder strRandom = new StringBuilder("");
for (int i = 0; i <10; i++)
{
   Random Rnd = new Random();
   int Rand = Rnd.Next(20);
   strRandom = strRandom.Append(Rand.ToString() + "," + System.Environment.NewLine);
   Rnd = null;
}
Lbl.Text = strRandom.ToString();

Random Produces Pseudo-Random Numbers

The exact sequence of random numbers generated by the Random class depends on the seed value with which the random number generator is instantiated. Given identical seed values, instances of the Random class will generate identical sequences of random numbers.

In the case of this example, the parameterless constructor instantiates a Random instance with a seed value based on the system clock. Given the speed with which the for loop in this example executes, the practical effect is that each instance of Random is passed the same seed value. As a result, the same sequence of random numbers is generated. This is mentioned in the documentation at http://msdn.microsoft.com/en-us/library/system.random.aspx: "However, because the clock has finite resolution, using the parameterless constructor to create different Random objects in close succession creates random number generators that produce identical sequences of random numbers." The documentation for the default constructor at http://msdn.microsoft.com/en-us/library/h343ddh9.aspx contains more detail: "The default seed value is derived from the system clock and has finite resolution. As a result, different Random objects that are created in close succession by a call to the default constructor will have identical default seed values and, therefore, will produce identical sets of random numbers. This problem can be avoided by using a single Random object to generate all random numbers. You can also work around it by modifying the seed value returned by the system clock and then explicitly providing this new seed value to the Random(Int32) constructor."

In the case of this example, instantiating a single Random object outside of the for loop solves the problem:

      StringBuilder strRandom = new StringBuilder("");
      Random Rnd = new Random();
      for (int i = 0; i <10; i++)
      {
         int Rand = Rnd.Next(20);
         strRandom = strRandom.Append(Rand.ToString() + "," + System.Environment.NewLine);
      }
      Console.WriteLine(strRandom.ToString());

I hope that this helps.

--Ron Petrusha
Common Language Runtime Developer Content
Microsoft Corporation

  open System
// The MAIN in F#
[<STAThread>]
[<EntryPoint>]
let main (args) =
    let urandom = new Random()
    match args with
    | _ ->
    // this will sleep for a random time multiplied by 10...
    System.Threading.Thread.Sleep(10 * urandom.Next());
    0

I'm studing the Random numbers generation and I never get the max value of my random.Next when setting the minValue and maxValue.

Here's the code I'm using:


Dim rnd As New Random

For i = 0 To 1500000
Dim num = rnd.Next(1, 9)

If num = 9 Then
MsgBox("i=" & i & " - num=" & num)
End If
Next

This code loops 1,500,000 times generating a random number between 1 and 9 and never gets 9 as the generated number.

If I set rnd.Next(1,10) I can get 9 before the 10th loop...

Is there any rule I missed about the ".Next" method used with minValue and maxValue does return the "maxValue" at all? (or should I just use "maxValue +1" to get the maximum value returned from this function?)

Regards,
Victor

Why Random.Next Never Returns the Maximum Value

The behavior that you're describing is documented and is by design. According to the documentation, the maxValue parameter in the Random.Next(Int32, Int32) method represents "the exclusive upper bound of the random number returned." "Exclusive" means that that value is not part of the set. In other words, the second integer parameter represents the first integer that is outside the range of the values returned by the method.

Actually, there are three overloads of Random.Next, and each behaves in this way. The parameterless overload returns an integer that is greater than or equal to zero and less than Int32.MaxValue. Random.Next(Int32) returns an integer that ranges from zero to one less than its parameter. And Random.Next(Int32, Int32) returns an integer that ranges from the value of its first parameter to one less than the value of its second parameter.

--Ron Petrusha
Common Language Runtime Developer Content
Microsoft Corporation

I created RandomGenerator class in my tool suit so that any of the random types can very easily be generated here is the code:


public static class RandomGenerator
{
    private static readonly Random random = new Random(); 

    private static readonly object syncLock = new object(); 

    public static bool GetBoolean()
    {
        lock (syncLock)
        {
            return (random.Next(2) == 1);
        }
    }

    public static int GetInteger(int MaxValue)
    {
        lock (syncLock)
        {
            return random.Next(0, MaxValue);
        }
    }

    public static byte GetByte()
    {
        return ((byte)GetInteger(256));
    }

    public static string GetUppercaseAlphabetString(int size)
    {
        StringBuilder builder = new StringBuilder();
        char ch;
        for (int i = 0; i < size; i++)
        {
            ch = Convert.ToChar(65 + GetInteger(27));
            builder.Append(ch);
        }
        return builder.ToString();
    }

    public static DateTime GetDateBetween1995andNow()
    {
        DateTime start = new DateTime(1995, 1, 1); 
        int range = ((TimeSpan)(DateTime.Today - start)).Days;
        return start.AddDays(GetInteger(range));
    }

    public static double GetDouble()
    {
        lock (syncLock)
        {
            return random.NextDouble();
        }
    }
}

I investigated the System.Random implementation.    The reference cites Knuth 1981 book (actually p. 171-172) used the subtractive lagged Fibonacci generator of (24, 55) which gurantees the period to be at least 2^55 -1.  Unfortunately .NET Reflector shows that the last three lines of Random(int Seed) has this.inext = 0; this.inextp = 21; .   The "21" should be "31" ( =55-24).   Thus the current implementation has no guarantee on the period at all.   The implementation is very similar to Numerical Recipes Ran3 routine (rather than Knuth original) and you would have detected the value 21 is wrong.    Can someone at Microsoft comment on this?    Did this "wrong" generator pass suites of tests like DieHard?