浅析Java源码之Math.random()
从零自学java消遣一下，看书有点脑阔疼，不如看看源码！(๑╹◡╹)ﾉ"""
JS中Math调用的都是本地方法，底层全是用C++写的，所以完全无法观察实现过程，Java的工具包虽然也有C/C++的介入，不过也有些是自己实现的。
本篇文章主要简单阐述Math.random()的实现过程。
Math隶属于java.lang包中，默认加载。本身是一个final类，方法都是静态方法，所以使用的时候不需要生成一个实例，直接调用Math.XX就行了。
一步一步观察该方法，首先是java.lang.Math：
public final class Math {
// 大量静态变量与方法
// ...
private static Random randomNumberGenerator;
private static synchronized void initRNG() {
if (randomNumberGenerator == null)
randomNumberGenerator = new Random();
}
public static double random() {
if (randomNumberGenerator == null) initRNG();
return randomNumberGenerator.nextDouble();
}
// ...other
}
这里面与random相关的操作有3个：
1、声明一个私有静态Random类randomNumberGenerator
2、若randomNumberGenerator未初始化，调用new Random()将其初始化
3、若randomNumberGenerator已经初始化，调用nextDouble方法并将其值返回
tips：synchronized关键字代表同步执行此方法，Java为多线程，所以为了保证randomNumberGenerator对象只被初始化一次，需要该关键字。比如两个线程同时调用了Math.random()，线程A发现rXX未被初始化，进入initRNG调用new Random()方法。此时线程B也发现了rXX未被初始化，但是initRNG是同步方法，所以挂起等待线程A执行完毕。当线程A执行完后把rXX初始化了，所以在initRNG中的if判断，线程B会直接返回。
所以简单来讲，random方法会在第一次调用时生成一个randomNumberGenerator对象，并调用其nextDouble方法生成随机数，之后的调用就只要持续调用此方法返回随机数就行了。
下面来看Random类是个什么鬼，来源于java.util.Random：
public class Random implements java.io.Serializable {
// 静态变量
/** use serialVersionUID from JDK 1.1 for interoperability */
static final long serialVersionUID = 3905348978240129619L;
private final AtomicLong seed;
private final static long multiplier = 0x5DEECE66DL;
private final static long addend = 0xBL;
private final static long mask = (1L << 48) - 1;
// constructor
public Random() { this(++seedUniquifier + System.nanoTime()); }
private static volatile long seedUniquifier = 8682522807148012L;
public Random(long seed) {
this.seed = new AtomicLong(0L);
setSeed(seed);
}
// 设置种子
synchronized public void setSeed(long seed) {
seed = (seed ^ multiplier) & mask;
this.seed.set(seed);
haveNextNextGaussian = false;
}
// 产生大数字
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));
}
// 生成随机数
public double nextDouble() {
return (((long)(next(26)) << 27) + next(27))
/ (double)(1L << 53);
}
// 其他不关心的方法
// nextBytes(bytes [])
// nextInt
// nextInt(int)
// nextLong
// nextBoolean
// nextFloat
// Serializable相关
}
上述代码剔除了大量的注释，还有一些不需要关心的方法，本文只关注Math.random()调用相关方法。
对于这个类，首先来看看它的构造函数，理论上new一个Random实例是需要一个long类型的整数作为参数，但是代码用了this使其默认调用new Random(long)这个构造函数。而在构造函数中又生成了一个新类并赋值给实例变量seed，关于这个AtomicLong类其实没啥好讲的，简单看一下就行：
public class AtomicLong extends Number implements java.io.Serializable {
private static final long serialVersionUID = 1927816293512124184L;
// valueOffset相关...
// 实例变量
private volatile long value;
// 构造函数
public AtomicLong(long initialValue) {
value = initialValue;
}
public AtomicLong() {}
// 方法
public final long get() {
return value;
}
public final void set(long newValue) {
value = newValue;
}
// 这个也会用到 但是不用关心具体实现
public final boolean compareAndSet(long expect, long update) {
return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
}
// 其余不需要关心（其实我也看不懂）的方法
}
如果思想简单一点，可以看出这个类也很简单，初始化传参赋值，set设置，get获取，多简单！
现在回到Random类的构造函数中，实例变量被赋值，类的value为初始化的0(后缀L代表这是一个long类型整数)。下一步调用setSeed，传入构造函数的long类型seed变量(不是seed类)，其值为：
++seedUniquifier + System.nanoTime()
// private static volatile long seedUniquifier = 8682522807148012L(8.6825e+15);
// 2^52 ~ 2^53
// 写文章时测试 => System.nanoTime() => 13230650355964(1.323e+13);
其中第一个变量为一个固定值，每次加1，另外一个为System.nanoTime()，该方法返回一个与当前时间相关的数字，具体我不关心。
两个相加后，作为初始种子出传入setSeed方法中，方法第一步会对seed进行二次计算：
seed = (seed ^ multiplier) & mask;
// private final static long multiplier = 0x5DEECE66DL;(25214903917 => 2.5214e+10)
// 2^34 ~ 2^35
// private final static long mask = (1L << 48) - 1;(2^48-1 => 0111...1 => 2^48 = 2.8147+e14)
此处进行的是位运算，这里不用关心具体数值，只关注可能得到的最大最小值。
^ => 异或运算：3 ^ 4 => 011 ^ 100 = 111 => 7(不一样置1，否则置0)
可以看出，两个数字异或运算，假设其中较大的二进制位数为n，结果一定是小于等于2n-1，比如34，4为100三位，所以结果一定小于等于2^3-1，即7。
& => 与运算：3 & 4 => 011 & 100 = 000 => 0(都为1置1，否则置0)
可以看出，与运算的结果总是小于等于较小的那个数。
这样来再来看之前的位运算：
seed(2^52 ~ 2^53) ^ multiplier(2^34 ~ 2^35) => 0 ~ (2^53-1)
(seed ^ multiplier)(0 ~ 2^53-1) & mask(2^48-1) => 0 ~ 2^48-1
结论是种子的范围是在0 ~ 2^48-1之间。
测试代码：
public class test {
public static void main(String [] args){
pro b = new pro();
System.out.println(b.getValue());
// 256403749474577
// 256458702577093
// 256431328421593
}
}
class pro{
long seed = 8682522807148012L + System.nanoTime();
long multiplier = 0x5DEECE66DL;
long mask = (1L << 48) - 1;
long getValue(){
return (seed ^ multiplier) & mask;
}
}
构造函数调用完后，现在来看nextDouble，这个方法除去位运算，本质上就是调用了两次next方法：
public double nextDouble() {
return (((long)(next(26)) << 27) + next(27))
/ (double)(1L << 53);
}
所以直接看next方法：
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));
}
方法内部声明了2个long类型种子：oldseed、nextseed，通过get方法取得之前位运算得到的seed赋值给oldseed，然后再次通过运算得到一个nextseed的值，并传给seed.compareAndSet(oldseed, nextseed)方法中。
关于这个方法，源码里是这样的：
// java.util.concurrent.atomic.AtomicLong;
public class AtomicLong extends Number implements java.io.Serializable {
public final boolean compareAndSet(long expect, long update) {
return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
}
}
// sun.misc.Unsafe.java
public native boolean compareAndSwapLong(Object obj, long offset,long expect, long update);
这个方法是个内部方法，也就是用C/C++实现的，所以有兴趣的自己去看源码，这里贴一个blog：
http://www.cnblogs.com/Mainz/p/3546347.html
方法的用处简单讲也很简单，比较oldseed与内存中预期的值，如果符合，就将nextseed放进去。
这里的运算也不管具体数值，oldseed * multiplier按最大计算会出现溢位，截取成long类型后的大小不确定，所以按照与运算这里的范围依然是0 ~ mask，即0 ~ 2^48-1。
最后返回(int)(nextseed >>> (48 - bits))，这里对结果进行类型处理，贴一个类型范围图：
| 基本类型 | 最小值 | 最大值 |
|---|---|---|
| byte | -2^7 | 2^7 - 1 |
| short | -2^15 | 2^15 - 1 |
| int | -2^31 | 2^31 - 1 |
| long | -2^63 | 2^63 - 1 |
| 若结果是大于int类型最大值，超出的部分会被直接截取砍掉。 |
最后看nextDouble的计算式：
(((long)(next(26)) << 27) + next(27)) / (double)(1L << 53)
传入的bits分别为26与27，这时返回的随机数为：
(int)(nextseed >>> 22) 与 (int)(nextseed >>> 21)
>>>为无符号右移，具体意思就不解释了。
得到的结果范围大概是 0 ~ 2^26(27)-1，理论上在这里是不会超过int的最大值。
当seed(测试代码中的tmp)为mask时，此时计算会达到最大值：
(((long)(1L << 53)-1 ) / (double)(1L << 53)
测试代码：
public class test {
public static void main(String [] args){
testb bb = new testb();
long a = (long)bb.getNext(26);
long b = bb.getNext(27);
double c = 1L << 53;
double d = ((a<<27) +b)/c;
// 0.99999999...
System.out.println(d);
}
}
class testb{
long tmp = (1L<<48)-1;
// long tmp = 0 => 0.0
int getNext(int num){
return (int)(tmp >>> (48 - num));
}
}
当测试代码中tmp为0时，计算结果为最小值0。
每一次调用nextDouble，会生成不一样的seed，也就会返回不一样的数字。
这样就是整个随机数生成过程。
完结，撒花ヽ(ﾟ∀ﾟ)ﾒ(ﾟ∀ﾟ)ﾉ
