Random和ThreadLocalRandom的实现原理
从JDK 7 开始引进了一个新的伪随机数生成器，ThreadLocalRandom，从名称可看出是一个与线程相关的Random，和之前的Random进行对比，ThreadLocalRandom在性能上和多线程并发处理上做了一些改进。
1，sun.misc.Unsafe
由于在产生伪随机数过程中,Random和ThreadLocalRandom都使用到了一个特殊的包：sun.misc.Unsafe。先对此包作个简单介绍。
sun.misc.Unsafe在JDK源代码中，有多处出现。为了更高效和更简单，它提供了一些与平台相关的更底层的功能，即提供了JNI的某些简单功能的替代，Unsafe的大部分方法都是Native方法。从名称也可以看出，它提供的是从Java意义上来说是“不安全”的一些功能，因此不应该在Java核心类库之外使用。实际上，除了通过反射机制，我们也无法获取到Unsafe的实例，使用它的功能。
更具体的介绍，可参看：http://mishadoff.com/blog/java-magic-part-4-sun-dot-misc-dot-unsafe。
2，理解Random：
从Random的介绍中可看出，一个Random类的实例可用于生成一个伪随机数。生成伪随机数的过程，是指定一个seed，然后通过一个公式来生成一个新的seed，并且根据新的seed值得到伪随机数。而如果两个不同的Random实例，指定的seed相同，则生成的伪随机数也相同。
代码展示： seed相同，则生成的随机数相同；
public static void main(String[] args) {
// TODO Auto-generated method stub
int currentseed = 100;
System.out.println("current seed:" + currentseed);
Random r1 = new Random(currentseed);
int value1 = r1.nextInt();
Random r2 = new Random(currentseed);
int value2 = r2.nextInt();
System.out.println("Random Object: " + r1.hashCode() + " AND " + r2.hashCode());
System.out.println("get random int:" + value1 + "," + value2);
}
运行结果如下：
current seed:100 Random Object: 1311053135 AND 118352462 get random int:-1193959466,-1193959466
通过运行结果可以看出，相同的seed,不同的Random对象，生成的随机数是一样的。
在多个线程使用多个Random实例时，如果指定的seed是相同的，则生成的伪随机数序列也是相同的。因此需要使用不同的seed来创建Random实例，比如使用Random默认的seed，或使用当前的时间System.currentTimeMillis();
代码展示：多线程中，seed相同，则生成的随机数相同；
public static void main(String[] args) {
// TODO Auto-generated method stub
int currentseed = 100;
System.out.println("current seed:" + currentseed);
RandomThread rThread1 = new RandomThread(currentseed);
new Thread(rThread1).start();
RandomThread rThread2 = new RandomThread(currentseed);
new Thread(rThread2).start();
}
public class RandomThread implements Runnable {
private int seed;
public RandomThread(int seed) {
super();
this.seed = seed;
}
public void run() {
// TODO Auto-generated method stub
Random r1 = new Random(seed);
try {
for(int k =0 ;k<5;k++){
int value1 = r1.nextInt();
System.out.println("get random int" + k + ":" + value1);
Thread.sleep(200);
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
运行结果：
current seed:100 get random int0:-1193959466 get random int0:-1193959466 get random int1:-1139614796 get random int1:-1139614796 get random int2:837415749 get random int2:837415749 get random int3:-1220615319 get random int3:-1220615319 get random int4:-1429538713 get random int4:-1429538713
在两个线程中，实例化两个Random，使用相同的seed，则产生了完全相同的两个随机数序列。
从Random中获取随机数的源代码：
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));
}
private static final long multiplier = 0x5DEECE66DL;
private static final long addend = 0xBL;
private static final long mask = (1L << 48) - 1;
，从源代码中可以看出，在生成随机数时，使用的公式：
nextseed = (oldseed * multiplier + addend) & mask;
其中，oldseed则为传进去的初始seed。而其他三个参数,multiplier,addend和mask，都为类静态变量。因此即使是不同的Random实例，生成的nextseed值也是相同的，所得的的随机数也就是相同的。
因此如果要确保随机数的效果，可以在多个线程中，使用同一个Random实例，这样就只需要维护同一套seed值。而Random实例生成随机数时对seed值的更新是一个原子操作，因此多个线程可能会在此产生阻塞而影响并发性能。
获取随机数时的最后一行操作，更新seed值，是一个原子操作，AtomicLong类中直接通过调用unsafe.compareAndSwapLong方法完成。
private final AtomicLong seed;
//seed值设置成了final,当初始化seed值之后，再不能通过Java代码来修改seed值。
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));
}
//seed.compareAndSet(oldseed, nextseed) 操作,调用unsafe的方法。
public final boolean compareAndSet(long expect, long update) {
return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
}
其中 seed.compareAndSet(oldseed, nextseed)，调用unsafe的方法来完成。该方法通过获得seed的内存位置偏移量，来设置seed的值，用nextseed值替换oldseed值。注意seed变量是设置成final的，因此无法通过Java程序再修改seed值,在此通过unsafe调用native方法来完成seed值的更新。
代码展示多个线程共享同一个random实例时，从程序结果看，有一部分获取随机数的操作，花费的时间比较多，说明多线程使用同一Random时，容易产生阻塞：
public static void main(String[] args) {
// TODO Auto-generated method stub
int currentseed = 100;
Random currRandom = new Random(currentseed);
for(int k=0;k<20;k++){
RandomThread rThread1 = new RandomThread(currRandom);
new Thread(rThread1).start();
}
}
public class RandomThread implements Runnable {
private Random currentRandom;
public RandomThread(Random random) {
super();
this.currentRandom = random;
}
public void run() {
// TODO Auto-generated method stub
try {
for(int k =0 ;k<10;k++){
long currenttime = System.currentTimeMillis();
int value1 = currentRandom.nextInt(50);
System.out.println("get random int" + k + ":" + value1);
System.out.println("Cost time for random value:" + (System.currentTimeMillis() - currenttime));
Thread.sleep(100 * value1);
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
从以上的分析，可总结出Random存在的几个问题：
生成多个实例，浪费资源；
相同的seed值，产生的伪随机数序列相同，效果不理想；
多个线程共享同一个实例时，会降低并发性能。
因此ThreadLocalRandom应运而生。
3， 理解ThreadLocalRandom：
针对Random存在的一些问题，ThreadLocalRandom有针对性的进行了改进。
ThreadLocalRandom是单例模式，系统只保存一个ThreadLocalRandom实例。
程序通过ThreadLocalRandom.current(); 获取ThreadLocalRandom实例。
public static ThreadLocalRandom current() {
if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)
localInit();
return instance;
}
/**
* Initialize Thread fields for the current thread. Called only
* when Thread.threadLocalRandomProbe is zero, indicating that a
* thread local seed value needs to be generated. Note that even
* though the initialization is purely thread-local, we need to
* rely on (static) atomic generators to initialize the values.
*/
static final void localInit() {
int p = probeGenerator.addAndGet(PROBE_INCREMENT);
int probe = (p == 0) ? 1 : p; // skip 0
long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
Thread t = Thread.currentThread();
UNSAFE.putLong(t, SEED, seed);
UNSAFE.putInt(t, PROBE, probe);
}
获取实例时，针对每个线程，只在第一次进行本地变量的参数初始化，多个线程的seed值也都是不同的。因此多个线程使用ThreadLocalRandom，获得的随机数也不一样。
但是ThreadLocalRandom针对每一个线程，都保存一份变量值在本地内存，在第一次使用时，初始化各个变量值，并且赋值给每个变量。
在更新seed值时，也都是在操作本地内存，避免了多线程操作时，对变量值的同步，大大提高了并发性能。
我们可以看到，在ThreadLocalRandom中定义了一些变量，而这些变量的值，是通过Thread线程保存在本地，即每个线程都保存了一份变量：
//ThreadLocalRandom中各变量的定义，以及通过Unsafe，获取保存在本地内存中的地址。
// Unsafe mechanics
private static final sun.misc.Unsafe UNSAFE;
private static final long SEED;
private static final long PROBE;
private static final long SECONDARY;
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class<?> tk = Thread.class;
SEED = UNSAFE.objectFieldOffset
(tk.getDeclaredField("threadLocalRandomSeed"));
PROBE = UNSAFE.objectFieldOffset
(tk.getDeclaredField("threadLocalRandomProbe"));
SECONDARY = UNSAFE.objectFieldOffset
(tk.getDeclaredField("threadLocalRandomSecondarySeed"));
} catch (Exception e) {
throw new Error(e);
}
}
//Thread类中对每个变量的定义：
// The following three initially uninitialized fields are exclusively
// managed by class java.util.concurrent.ThreadLocalRandom. These
// fields are used to build the high-performance PRNGs in the
// concurrent code, and we can not risk accidental false sharing.
// Hence, the fields are isolated with @Contended.
/** The current seed for a ThreadLocalRandom */
@sun.misc.Contended("tlr")
long threadLocalRandomSeed;
/** Probe hash value; nonzero if threadLocalRandomSeed initialized */
@sun.misc.Contended("tlr")
int threadLocalRandomProbe;
/** Secondary seed isolated from public ThreadLocalRandom sequence */
@sun.misc.Contended("tlr")
int threadLocalRandomSecondarySeed;
//在ThreadLocalRandom中，是针对每个线程，进行seed的读取和更新。不存在多个线程共享的问题，因此也不存在影响并发性能的问题。
final long nextSeed() {
Thread t; long r; // read and update per-thread seed
UNSAFE.putLong(t = Thread.currentThread(), SEED,
r = UNSAFE.getLong(t, SEED) + GAMMA);
return r;
}
在ThreadLocalRandom中，是针对每个线程，对该线程的变量seed进行读取和更新。不存在多个线程共享的问题，因此也不存在影响并发性能的问题。