一、Random類的構造函數，官方文檔如下：
Random類的構造函數
1.無參的構造函數，源碼如下：
/**
* Creates a new random number generator. This constructor sets
* the seed of the random number generator to a value very likely
* to be distinct from any other invocation of this constructor.
*/
public Random() {
this(seedUniquifier() ^ System.nanoTime());
}
其中seedUniquifier()函數，個人認為是產生一個隨機數，System.nanoTime()函數返回一個納秒級的時間值（這個時間代表什么不重要，此函數多用來計算流逝的時間，精度很高，詳見源碼及參考資料），源碼中定義分別如下：
private static long seedUniquifier() {
// L'Ecuyer, "Tables of Linear Congruential Generators of
// Different Sizes and Good Lattice Structure", 1999
for (;;) {
long current = seedUniquifier.get();
long next = current * 181783497276652981L;
if (seedUniquifier.compareAndSet(current, next))
return next;
}
}
/**
* Returns the current value of the running Java Virtual Machine's
* high-resolution time source, in nanoseconds.
*
* <p>This method can only be used to measure elapsed time and is
* not related to any other notion of system or wall-clock time.
* The value returned represents nanoseconds since some fixed but
* arbitrary <i>origin</i> time (perhaps in the future, so values
* may be negative). The same origin is used by all invocations of
* this method in an instance of a Java virtual machine; other
* virtual machine instances are likely to use a different origin.
*
* <p>This method provides nanosecond precision, but not necessarily
* nanosecond resolution (that is, how frequently the value changes)
* - no guarantees are made except that the resolution is at least as
* good as that of {@link #currentTimeMillis()}.
*
* <p>Differences in successive calls that span greater than
* approximately 292 years (2<sup>63</sup> nanoseconds) will not
* correctly compute elapsed time due to numerical overflow.
*
* <p>The values returned by this method become meaningful only when
* the difference between two such values, obtained within the same
* instance of a Java virtual machine, is computed.
*
* <p> For example, to measure how long some code takes to execute:
* <pre> {@code
* long startTime = System.nanoTime();
* // ... the code being measured ...
* long estimatedTime = System.nanoTime() - startTime;}</pre>
*
* <p>To compare two nanoTime values
* <pre> {@code
* long t0 = System.nanoTime();
* ...
* long t1 = System.nanoTime();}</pre>
*
* one should use {@code t1 - t0 < 0}, not {@code t1 < t0},
* because of the possibility of numerical overflow.
*
* @return the current value of the running Java Virtual Machine's
* high-resolution time source, in nanoseconds
* @since 1.5
*/
public static native long nanoTime();
「注：其中nanoTime()函數，用native關鍵字修飾，由本地代碼實現。」
兩者異或運算后，初始化類成員變量seed，此變量會成為隨機函數的種子，所有的隨機算法都由種子數算起，定義如下：
/**
* The internal state associated with this pseudorandom number generator.
* (The specs for the methods in this class describe the ongoing
* computation of this value.)
*/
private final AtomicLong seed;
2.有參的構造函數，源碼如下：
/**
* Creates a new random number generator using a single {@code long} seed.
* The seed is the initial value of the internal state of the pseudorandom
* number generator which is maintained by method {@link #next}.
*
* <p>The invocation {@code new Random(seed)} is equivalent to:
* <pre> {@code
* Random rnd = new Random();
* rnd.setSeed(seed);}</pre>
*
* @param seed the initial seed
* @see #setSeed(long)
*/
public Random(long seed) {
if (getClass() == Random.class)
this.seed = new AtomicLong(initialScramble(seed));
else {
// subclass might have overriden setSeed
this.seed = new AtomicLong();
setSeed(seed);
}
}
構造函數由傳入的種子參數進行初始化，不難理解，值得注意的是，由同一個種子初始化的Random對象，相同次數調用時，產生的隨機數相同。舉例如下：
public static void main(String[] args) {
Random random = new Random(47);
for(int i = 0; i < 3; i++){
System.out.print(random.nextInt(20) + " ");
}
System.out.println();
Random randomII = new Random(47);
for(int i = 0; i < 3; i++){
System.out.print(randomII.nextInt(20)+ " ");
}
}
輸出如下：
18 15 13
18 15 13
二、Java隨機數原理
大多數語言實現偽隨機數，均采用線性同余方程（linear congruential generator），詳細內容參照「資料1」.
Java中使用的是48-bit的種子，然后調用線性同余方程，源碼如下：
protected int next(int bits) {
long oldseed, nextseed;
AtomicLong seed = this.seed;
do {
oldseed = seed.get();
nextseed = (oldseed * multiplier + addend) & mask; //此處為核心，線性同余方程的實現
} while (!seed.compareAndSet(oldseed, nextseed));
return (int)(nextseed >>> (48 - bits));
}
經常在隨機數中調用的函數nextInt()，源碼如下：
public int nextInt(int bound) {
if (bound <= 0)
throw new IllegalArgumentException(BadBound);
int r = next(31);
int m = bound - 1;
if ((bound & m) == 0) // i.e., bound is a power of 2
r = (int)((bound * (long)r) >> 31);
else {
for (int u = r;
u - (r = u % bound) + m < 0;
u = next(31))
;
}
return r;
}
此處實現應該是最新版，與資料中提供的源碼略有不同，函數中幾處細節尚未理解，想清楚之后再回來補充。
Reference:
