Re: java.util.Random.nextInt() thread safety
Eric Sosman wrote:
Patricia Shanahan wrote On 08/28/06 23:19,:
Sakagami Hiroki wrote:
Hi,
Is java.util.Random.nextInt() thread safe? I can't find whether it is
or not in the javadoc API document.
I want to use it like this:
import java.util.Random;
public class Foo {
private static final Random rng = new Random();
private final int myID = rng.nextInt();
public int getMyID() {
return myID;
}
}
Regards,
--
Sakagami Hiroki
Time for one of my standard rants.
A long time ago, Sun noticed that programmers need to know the
multi-thread safety of functions they call, and devised a scheme
that is used throughout the Solaris documentation. The man page for each
Solaris system call or library function is required to directly state
the "MT-Level", in a fixed section of the man page.
Why, Why, WHY didn't Sun apply this sane, programmer-friendly scheme to
the Java documentation?
Indeed, I would like Javadoc to have a standard set of terms for the
multi-thread safety, and an option to warn if it is not stated.
Anyway, I've taken a look at the Random nextInt() code in 1.5. It uses
an AtomicLong for the seed, and does a compareAndSet to update it, so
all should be well.
(Disclaimer: I work for Sun, but I don't speak for Sun.)
The Javadoc shows that java.util.Random#nextInt() is just
a call on the next() method, and that java.util.Random#next()
is thread-safe. What can be inferred about the thread-safety
of nextInt()?
How did you find out from the documentation that next() is thread safe?
The sample implementation in the JDK 1.5.0 documentation is not,
although the code is.
In any case, even if Random were final I would not know, without looking
at the nextInt() source code, that it does not use or modify any
variables. I already know from looking at next() that sample
implementations in the javadocs are abstractions that do not necessarily
match the thread safety of the real code.
Not much, because when nextInt() calls next() it might not
be calling java.util.Random#next()! Random is a non-final
class that can be extended, and an extending class can override
the next() method -- indeed, that's probably the main reason to
extend Random (so you can plug in the Mersenne Twister, say,
instead of java.util.Random's less rigorous generator). Since
nextInt() "inherits" its thread-safety or lack thereof from the
next() implementation, and since the universe of implementations
is unknown ...
The Javadoc could probably be improved, but I don't see how
a formal thread-safety annotation could be made to work for a
non-final class. Perhaps a natural-language statement to the
effect that the methods of Random are thread-safe if used with
Random's own implementations would be helpful, but that's about
as far as I think one could go without creating a false sense
of security.
Anything the Javadoc says about a non-final method in a non-final class,
that is not forced by the declaration, can be broken by a subclass.
For example, one could override nextInt(int) always return 42,
regardless of the state of the seed or the value of the int parameter.
Does that make it inappropriate for the Javadoc to say "Returns a
pseudorandom, uniformly distributed int value between 0 (inclusive) and
the specified value (exclusive),..."?
I would view a Javadoc thread safety statement exactly the same way I
view a range limit within type, or a statement about postconditions in
general, as a contract that the Sun-supplied implementation does follow,
and that a subclass should follow.
Patricia