首先介绍一下随机数生成的概念
Java随机数的核心就是种子,在Random中其实就是一个AtomicLong类型的变量。
private final AtomicLong seed;
随机数的生成依赖于种子,当我们通过new Random()创建一个随机数生成器,会通过计算为我们默认生成一个种子的计算值,再通过这个种子的计算值运算得出最终的种子。下面这段代码是Random默认生成种子计算值的逻辑。
public Random() {
this(seedUniquifier() ^ System.nanoTime());
}
private static final AtomicLong seedUniquifier = new AtomicLong(8682522807148012L);
private static long seedUniquifier() {
for (;;) {
long current = seedUniquifier.get();
long next = current * 181783497276652981L;
if (seedUniquifier.compareAndSet(current, next))
return next;
}
}
我们也可以在初始化时给定种子的计算值,再通过计算生成最终的种子。
public Random(long seed) {
// 主要就是下面这行代码
this.seed = new AtomicLong(initialScramble(seed));
}
// 通过计算让种子变得复杂
private static long initialScramble(long seed) {
return (seed ^ multiplier) & mask;
}
111111111111111111111111111111111111111111111111——mask(48位二进制)
10111011110111011001110011001101101——multiplier
—— 总结:随机数的生成依靠种子,种子的生成依靠于种子的计算值,种子的计算值可以由我们给定,也可以由Random默认的通过当前时间的纳秒计算得到,种子的计算值通过一系列的运算得到最终的种子。
下面来介绍随机数是如何生成的
上面提到,随机数的生成依靠于种子,通过一个种子生成出随机数后,那么该种子就不可用了,因为通过该种子生成的随机数还会是一样的,因此需要通过旧的种子生成新的种子,以应对下一次随机数的生成。
下面先看看Random.next()方法,该方法用于生成新的种子。
nextInt(),nextLong()等方法都是通过调用该方法保留种子的固定长度,再通过该部分种子计算出随机数。
eg.int则保留31位,long则保留63位——
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) {
int r = next(31); // 保留31位的种子
int m = bound - 1; // 生成随机数的最大值,也就是不包含bound边界值
if ((bound & m) == 0) // 如果边界值是2的幂
// eg. bound = 8, r = xxx,xxx是31位2进制)
// 1111111111111111111111111111110 * 1000 =
// 1111111111111111111111111111110000(相当于直接把000加在了原来的二进制后面)
// 1111111111111111111111111111110000 >> 31 = 111
r = (int)((bound * (long)r) >> 31);
else {
for (int u = r;
u - (r = u % bound) + m < 0;
u = next(31))
;
}
return r;
}
—— 总结:随机数的生成依靠种子,种子的生成依靠于种子的计算值,种子的计算值可以由我们给定,也可以由Random默认的通过当前时间的纳秒计算得到,种子的计算值通过一系列的运算得到最终的种子。每次都需要通过新生成的种子来构建我们的随机数。
Random真的存在线程安全问题吗?
什么叫Random发生了线程安全问题?—— 当我们使用相同的种子去生成随机数,那么这两个随机数会是相同的,也就是如果我们使用多个线程去操作同一个Random,如果多个线程使用相同的种子去生成随机数,那么就会生成一系列相同的随机数。
但Random真的线程不安全吗?
回到之前这个通过旧种子生成新种子的逻辑,多个线程可以同时获取相同的旧种子,但这里通过CAS保证了只有一个线程可以通过旧种子生成新的种子 —— 也就是Random是线程安全的,但因为使用CAS,在高并发情况下,如果生成随机数频率过高,会影响效率。
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));
}
由于Random在高并发下效率低,因此考虑使用ThreadLocalRandom。线程会冲突的只有种子,因此只要把种子交给每个线程维护即可,因此结合ThreadLocal就成了ThreadLocalRandom,这里就不介绍了。
下面内容可以不看
通过代码进行测试,下面代码本来是用来测试Random是线程不安全的
(之前对Random印象不深,总是忘记Random在高并发下是效率低的,而不是线程不安全的)
1)创建自定义Random(copy代码),维护一个线程安全的Set(seedSet)用于存储新生成的种子
private Set<Long> seedSet = Collections.synchronizedSet(new HashSet<>());
2)修改next()方法,在成功生成新的种子后,将种子添加到seedSet
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));
seedSet.add(nextseed);
return (int)(nextseed >>> (48 - bits));
}
3)自定义Random暴露一个seedSize()方法,用于查看生成的种子数
public int seedSize() {
return seedSet.size();
}
4)下面创建200个线程,每个线程生成1000个随机数存到自己的HashSet,最后对每个线程生成的HashSet进行汇总,最后打印结果。
public class Test {
public static void main(String[] args) throws Exception {
Random random = new Random();
Set<Integer>[] sets = new Set[200];
CountDownLatch countDownLatch = new CountDownLatch(200);
for (int i = 0; i < 200; i++) {
new Thread(new RandomThread(random, sets, i, countDownLatch)).start();
}
countDownLatch.await();
Set<Integer> totalSet = new HashSet<>();
for (int i = 0; i < 200; i++) {
for (int j : sets[i]) {
totalSet.add(j);
}
}
System.out.println("预计" + (1000 * 200) + ",实际" + totalSet.size() + ",重复了" + ((1000 * 200) - totalSet.size()));
System.out.println("总共生成的种子数:" + random.seedSize());
}
}
class RandomThread implements Runnable {
private Random random;
private Set<Integer>[] sets;
private int num;
private CountDownLatch countDownLatch;
public RandomThread(Random random, Set<Integer>[] sets, int num, CountDownLatch countDownLatch) {
this.random = random;
this.sets = sets;
this.num = num;
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
Set<Integer> set = sets[num];
if (set == null) {
set = new HashSet<>(1000);
sets[num] = set;
}
set.add(random.nextInt(Integer.MAX_VALUE));
}
countDownLatch.countDown();
}
}
测试多次结果
预计200000,实际199983,重复了17
总共生成的种子数:200000
预计200000,实际199991,重复了9
总共生成的种子数:200000
预计200000,实际199993,重复了7
总共生成的种子数:200000
上述内容,如有错误,欢迎指正