java - Should I use a global instance of java.util.Random, or construct one everytime it is used?

Question

The title pretty much sums it up. I have seen people construct an instance of Random globally, and use it in all of their code, and I have also seen people that construct an instance everytime they want to use Random.

My question is: When, if ever, should I construct a new instance of Random for generating random numbers?

Math.random() stores a Random instance in a RandomNumberGeneratorHolder, and calls it every time Math.random() is called.

My view: I should use a global Random() instance, because:

1. Save the time of object creation. The no-arg constructor of Random() calls seedUniquifier(), which basically loops forever until it finds a new AtomicLong(), and raises it to the power of System.nanoTime(). Pretty expensive.
2. I am currently using random numbers for a custom hashCode(). I overrided equals(), and now I am doing the same for hashCode(). The class that I am doing this on will be mostly used to store data in Collections, which heavily abuses hashCode(). Seeing the no-arg Random() constructor will take more time than a couple of multiplications that I am using to generate my hashcode, it will more than double the execution time. Not good.

I can't think of any more reasons, but if I should use a global Random instance, I can imagine java developers implementing Random with at instance field, in addition to the constructor for special cases. That tells me that I am wrong. Should I use a global Random instance?

Answer 1

You should use a global Random instance for performance reasons, instead of initializing one each time - see also API.

Please note that:

• for multi-threaded applications, you should use a ThreadLocalRandom instead, in the form of ThreadLocalRandom.current().next... for each call (see official recommendation on the matter).
• for cryptographically secure random numbers, use a SecureRandom instead.

Answer 2

In a single threaded program it's okay to use a single Random object for the duration of the program.

In a multi-threaded program it's required that threads don't share a single Random object. One way to achieve this is to use ThreadLocalRandom or ThreadLocal and Random.